Commit 282d5446a094a6728150265015de8fa6a3f370cc - eclipse-platform-text

+11

-0

.project less more

	0	<?xml version="1.0" encoding="UTF-8"?>
	1	<projectDescription>
	2	<name>eclipse.platform.text</name>
	3	<comment></comment>
	4	<projects>
	5	</projects>
	6	<buildSpec>
	7	</buildSpec>
	8	<natures>
	9	</natures>
	10	</projectDescription>

+2

-1

org.eclipse.core.filebuffers/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %pluginName
3	3	Bundle-SymbolicName: org.eclipse.core.filebuffers; singleton:=true
4		Bundle-Version: 3.6.100.qualifier
	4	Bundle-Version: 3.6.200.qualifier
5	5	Bundle-Activator: org.eclipse.core.internal.filebuffers.FileBuffersPlugin
6	6	Bundle-ActivationPolicy: lazy
7	7	Bundle-Vendor: %providerName

17	17	org.eclipse.core.filesystem;bundle-version="[1.2.0,2.0.0)"
18	18	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
19	19	Import-Package: com.ibm.icu.text
	20	Automatic-Module-Name: org.eclipse.core.filebuffers

+1

-0

org.eclipse.core.filebuffers/forceQualifierUpdate.txt less more

0

Bug 534597 - Unanticipated comparator errors in I20180511-2000⏎

+2

-2

org.eclipse.core.filebuffers/pom.xml less more

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<groupId>org.eclipse.core</groupId>
19	19	<artifactId>org.eclipse.core.filebuffers</artifactId>
20		<version>3.6.100-SNAPSHOT</version>
	20	<version>3.6.200-SNAPSHOT</version>
21	21	<packaging>eclipse-plugin</packaging>
22	22	</project>

+1

-1

org.eclipse.core.filebuffers/src/org/eclipse/core/internal/filebuffers/FileStoreTextFileBuffer.java less more

531	531	}
532	532
533	533	in= new BufferedReader(new InputStreamReader(contentStream, encoding), BUFFER_SIZE);
534		StringBuffer buffer= new StringBuffer(BUFFER_SIZE);
	534	StringBuilder buffer= new StringBuilder(BUFFER_SIZE);
535	535	char[] readBuffer= new char[READER_CHUNK_SIZE];
536	536	int n= in.read(readBuffer);
537	537	while (n > 0) {

+1

-1

org.eclipse.core.filebuffers/src/org/eclipse/core/internal/filebuffers/ResourceTextFileBuffer.java less more

520	520	}
521	521
522	522	in= new BufferedReader(new InputStreamReader(contentStream, encoding), BUFFER_SIZE);
523		StringBuffer buffer= new StringBuffer(BUFFER_SIZE);
	523	StringBuilder buffer= new StringBuilder(BUFFER_SIZE);
524	524	char[] readBuffer= new char[READER_CHUNK_SIZE];
525	525	int n= in.read(readBuffer);
526	526	while (n > 0) {

+2

-1

org.eclipse.core.filebuffers.tests/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %Plugin.name
3	3	Bundle-SymbolicName: org.eclipse.core.filebuffers.tests;singleton:=true
4		Bundle-Version: 3.11.100.qualifier
	4	Bundle-Version: 3.11.200.qualifier
5	5	Bundle-Activator: org.eclipse.core.filebuffers.tests.FileBuffersTestPlugin
6	6	Bundle-ActivationPolicy: lazy
7	7	Bundle-Vendor: %Plugin.providerName

16	16	org.junit;bundle-version="4.12.0"
17	17	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
18	18	Eclipse-BundleShape: dir
	19	Automatic-Module-Name: org.eclipse.core.filebuffers.tests

+2

-2

org.eclipse.core.filebuffers.tests/pom.xml less more

13	13	<parent>
14	14	<artifactId>tests-pom</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	<relativePath>../tests-pom/</relativePath>
18	18	</parent>
19	19	<groupId>org.eclipse.core</groupId>
20	20	<artifactId>org.eclipse.core.filebuffers.tests</artifactId>
21		<version>3.11.100-SNAPSHOT</version>
	21	<version>3.11.200-SNAPSHOT</version>
22	22	<packaging>eclipse-test-plugin</packaging>
23	23	<properties>
24	24	<testSuite>${project.artifactId}</testSuite>

+2

-2

org.eclipse.core.filebuffers.tests/src/org/eclipse/core/filebuffers/tests/FileBufferCreation.java less more

68	68
69	69	private IPath createLinkedFile(String linkedFileName, String linkedFileTarget) throws CoreException {
70	70	IFile linkedFile= ResourceHelper.createLinkedFile(fProject, new Path(linkedFileName), FileBuffersTestPlugin.getDefault(), new Path(linkedFileTarget));
71		return linkedFile != null ? linkedFile.getFullPath() : null;
	71	return linkedFile.getFullPath();
72	72	}
73	73
74	74	private IPath createLinkedFolder(String linkedFolderName, String linkedFolderTarget) throws CoreException {
75	75	IFolder linkedFolder= ResourceHelper.createLinkedFolder(fProject, new Path(linkedFolderName), FileBuffersTestPlugin.getDefault(), new Path(linkedFolderTarget));
76		return linkedFolder != null ? linkedFolder.getFullPath() : null;
	76	return linkedFolder.getFullPath();
77	77	}
78	78
79	79	/*

+1

-1

org.eclipse.core.filebuffers.tests/src/org/eclipse/core/filebuffers/tests/FileBufferFunctions.java less more

861	861	IPath newLocation= moveUnderlyingFile();
862	862	if (newLocation != null) {
863	863	if (listener.count != 1 \|\| listener.buffer != fileBuffer \|\| !newLocation.equals(listener.newLocation)) {
864		StringBuffer buf= new StringBuffer();
	864	StringBuilder buf= new StringBuilder();
865	865	buf.append("Wrong listener notifcation in " + getClass().getName() + ":\n");
866	866	buf.append("listener.count: " + listener.count + " (expected: 1)\n");
867	867	if (newLocation.equals(listener.newLocation))

+7

-1

org.eclipse.core.filebuffers.tests/src/org/eclipse/core/filebuffers/tests/FileBuffersForNonExistingWorkspaceFiles.java less more

12	12	import static org.junit.Assert.assertFalse;
13	13	import static org.junit.Assert.assertNotNull;
14	14	import static org.junit.Assert.assertTrue;
	15
	16	import java.io.IOException;
15	17
16	18	import org.junit.After;
17	19	import org.junit.Test;

67	69
68	70	@Test
69	71	public void testBug118199_fixed() throws Exception {
70		IFile file= getProject().getWorkspace().getRoot().getFileForLocation(getPath());
	72	IPath location= getPath();
	73	IFile file= getProject().getWorkspace().getRoot().getFileForLocation(location);
	74	if (file == null) {
	75	throw new IOException("File '" + location + "' can not be found."); //$NON-NLS-1$ //$NON-NLS-2$
	76	}
71	77	IPath path= file.getFullPath();
72	78	assertFalse(file.exists());
73	79	fManager.connect(path, LocationKind.IFILE, null);

+7

-1

org.eclipse.core.filebuffers.tests/src/org/eclipse/core/filebuffers/tests/FileStoreFileBuffersForNonExistingWorkspaceFiles.java less more

10	10	package org.eclipse.core.filebuffers.tests;
11	11
12	12	import static org.junit.Assert.*;
	13
	14	import java.io.IOException;
13	15
14	16	import org.junit.After;
15	17	import org.junit.Test;

65	67
66	68	@Test
67	69	public void testBug118199_fixed() throws Exception {
68		IFile file= getProject().getWorkspace().getRoot().getFileForLocation(getPath());
	70	IPath location= getPath();
	71	IFile file= getProject().getWorkspace().getRoot().getFileForLocation(location);
	72	if (file == null) {
	73	throw new IOException("File '" + location + "' can not be found."); //$NON-NLS-1$ //$NON-NLS-2$
	74	}
69	75	IPath path= file.getFullPath();
70	76	assertFalse(file.exists());
71	77	fManager.connect(path, LocationKind.IFILE, null);

+4

-18

org.eclipse.core.filebuffers.tests/src/org/eclipse/core/filebuffers/tests/FileTool.java less more

63	63	String entryName = entry.getName();
64	64	File file = new File(dstDir, changeSeparator(entryName, '/', File.separatorChar));
65	65	file.getParentFile().mkdirs();
66		InputStream src = null;
67		OutputStream dst = null;
68		try {
69		src = zipFile.getInputStream(entry);
70		dst = new FileOutputStream(file);
	66	try (InputStream src= zipFile.getInputStream(entry); OutputStream dst= new FileOutputStream(file)) {
71	67	transferData(src, dst);
72		} finally {
73		if(dst != null){
74		try {
75		dst.close();
76		} catch(IOException e){
77		}
78		}
79		if(src != null){
80		try {
81		src.close();
82		} catch(IOException e){
83		}
84		}
85	68	}
86	69	}
87	70	} finally {

161	144	public static void copy(File src, File dst) throws IOException {
162	145	if(src.isDirectory()){
163	146	String[] srcChildren = src.list();
	147	if (srcChildren == null) {
	148	throw new IOException("Content from directory '" + src.getAbsolutePath() + "' can not be listed."); //$NON-NLS-1$ //$NON-NLS-2$
	149	}
164	150	for(int i = 0; i < srcChildren.length; ++i){
165	151	File srcChild= new File(src, srcChildren[i]);
166	152	File dstChild= new File(dst, srcChildren[i]);

+3

-3

org.eclipse.core.filebuffers.tests/src/org/eclipse/core/filebuffers/tests/MockDocumentSetupParticipants.java less more

57	57	@Override
58	58	public void setup(IDocument document, IPath location, LocationKind locationKind) {
59	59	if (locationKind == LocationKind.IFILE)
60		append(document, new StringBuffer(location.toPortableString()).reverse().toString());
	60	append(document, new StringBuilder(location.toPortableString()).reverse().toString());
61	61	}
62	62	}
63	63

65	65	@Override
66	66	public void setup(IDocument document, IPath location, LocationKind locationKind) {
67	67	if (locationKind == LocationKind.LOCATION)
68		append(document, new StringBuffer(location.toPortableString()).reverse().toString());
	68	append(document, new StringBuilder(location.toPortableString()).reverse().toString());
69	69	}
70	70	}
71	71

73	73	@Override
74	74	public void setup(IDocument document, IPath location, LocationKind locationKind) {
75	75	if (locationKind == LocationKind.NORMALIZE)
76		append(document, new StringBuffer(location.toPortableString()).reverse().toString());
	76	append(document, new StringBuilder(location.toPortableString()).reverse().toString());
77	77	}
78	78	}
79	79

+20

-0

org.eclipse.jface.text/.settings/org.eclipse.jdt.core.prefs less more

132	132	org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
133	133	org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
134	134	org.eclipse.jdt.core.compiler.source=1.8
	135	org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647
135	136	org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
136	137	org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
137	138	org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0

145	146	org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=48
146	147	org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
147	148	org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
	149	org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header=0
148	150	org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
	151	org.eclipse.jdt.core.formatter.alignment_for_module_statements=16
149	152	org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
	153	org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references=0
150	154	org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
151	155	org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
152	156	org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80

156	160	org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
157	161	org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
158	162	org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
	163	org.eclipse.jdt.core.formatter.alignment_for_type_arguments=0
	164	org.eclipse.jdt.core.formatter.alignment_for_type_parameters=0
159	165	org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
160	166	org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
161	167	org.eclipse.jdt.core.formatter.blank_lines_after_package=1

182	188	org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
183	189	org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
184	190	org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
	191	org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position=false
185	192	org.eclipse.jdt.core.formatter.comment.format_block_comments=false
186	193	org.eclipse.jdt.core.formatter.comment.format_header=false
187	194	org.eclipse.jdt.core.formatter.comment.format_html=true

214	221	org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
215	222	org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
216	223	org.eclipse.jdt.core.formatter.indentation.size=4
	224	org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant=insert
217	225	org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert
218	226	org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
219	227	org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert

408	416	org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=true
409	417	org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
410	418	org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=3
	419	org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=common_lines
	420	org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause=common_lines
	421	org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration=common_lines
	422	org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment=common_lines
	423	org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement=common_lines
	424	org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration=common_lines
	425	org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration=common_lines
	426	org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation=common_lines
	427	org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement=common_lines
	428	org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause=common_lines
411	429	org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
412	430	org.eclipse.jdt.core.formatter.tabulation.char=tab
413	431	org.eclipse.jdt.core.formatter.tabulation.size=4
414	432	org.eclipse.jdt.core.formatter.use_on_off_tags=false
415	433	org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
	434	org.eclipse.jdt.core.formatter.wrap_before_assignment_operator=false
416	435	org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
	436	org.eclipse.jdt.core.formatter.wrap_before_conditional_operator=true
417	437	org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
418	438	org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
419	439	org.eclipse.jdt.core.incompatibleJDKLevel=ignore

+59

-1

org.eclipse.jface.text/.settings/org.eclipse.jdt.ui.prefs less more

0	0	eclipse.preferences.version=1
	1	editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
1	2	formatter_profile=_JDT UI Code Style Conventions
2		formatter_settings_version=12
	3	formatter_settings_version=13
3	4	org.eclipse.jdt.ui.exception.name=e
4	5	org.eclipse.jdt.ui.gettersetter.use.is=true
5	6	org.eclipse.jdt.ui.ignorelowercasenames=true

8	9	org.eclipse.jdt.ui.ondemandthreshold=99
9	10	org.eclipse.jdt.ui.overrideannotation=true
10	11	org.eclipse.jdt.ui.staticondemandthreshold=99
	12	sp_cleanup.add_default_serial_version_id=false
	13	sp_cleanup.add_generated_serial_version_id=false
	14	sp_cleanup.add_missing_annotations=false
	15	sp_cleanup.add_missing_deprecated_annotations=true
	16	sp_cleanup.add_missing_methods=false
	17	sp_cleanup.add_missing_nls_tags=false
	18	sp_cleanup.add_missing_override_annotations=true
	19	sp_cleanup.add_missing_override_annotations_interface_methods=true
	20	sp_cleanup.add_serial_version_id=false
	21	sp_cleanup.always_use_blocks=false
	22	sp_cleanup.always_use_parentheses_in_expressions=false
	23	sp_cleanup.always_use_this_for_non_static_field_access=false
	24	sp_cleanup.always_use_this_for_non_static_method_access=false
	25	sp_cleanup.convert_functional_interfaces=false
	26	sp_cleanup.convert_to_enhanced_for_loop=false
	27	sp_cleanup.correct_indentation=false
	28	sp_cleanup.format_source_code=true
	29	sp_cleanup.format_source_code_changes_only=true
	30	sp_cleanup.insert_inferred_type_arguments=false
	31	sp_cleanup.make_local_variable_final=false
	32	sp_cleanup.make_parameters_final=false
	33	sp_cleanup.make_private_fields_final=false
	34	sp_cleanup.make_type_abstract_if_missing_method=false
	35	sp_cleanup.make_variable_declarations_final=false
	36	sp_cleanup.never_use_blocks=false
	37	sp_cleanup.never_use_parentheses_in_expressions=false
	38	sp_cleanup.on_save_use_additional_actions=true
	39	sp_cleanup.organize_imports=true
	40	sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
	41	sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=false
	42	sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=false
	43	sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
	44	sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
	45	sp_cleanup.remove_private_constructors=false
	46	sp_cleanup.remove_redundant_type_arguments=false
	47	sp_cleanup.remove_trailing_whitespaces=true
	48	sp_cleanup.remove_trailing_whitespaces_all=true
	49	sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
	50	sp_cleanup.remove_unnecessary_casts=false
	51	sp_cleanup.remove_unnecessary_nls_tags=false
	52	sp_cleanup.remove_unused_imports=false
	53	sp_cleanup.remove_unused_local_variables=false
	54	sp_cleanup.remove_unused_private_fields=false
	55	sp_cleanup.remove_unused_private_members=false
	56	sp_cleanup.remove_unused_private_methods=false
	57	sp_cleanup.remove_unused_private_types=false
	58	sp_cleanup.sort_members=false
	59	sp_cleanup.sort_members_all=false
	60	sp_cleanup.use_anonymous_class_creation=false
	61	sp_cleanup.use_blocks=false
	62	sp_cleanup.use_blocks_only_for_return_and_throw=false
	63	sp_cleanup.use_lambda=false
	64	sp_cleanup.use_parentheses_in_expressions=false
	65	sp_cleanup.use_this_for_non_static_field_access=false
	66	sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=false
	67	sp_cleanup.use_this_for_non_static_method_access=false
	68	sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=false

+7

-3

org.eclipse.jface.text/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %pluginName
3	3	Bundle-SymbolicName: org.eclipse.jface.text
4		Bundle-Version: 3.12.2.qualifier
	4	Bundle-Version: 3.13.0.qualifier
5	5	Bundle-Vendor: %providerName
6	6	Bundle-Localization: plugin
7	7	Export-Package:
8	8	org.eclipse.jface.contentassist,
9	9	org.eclipse.jface.contentassist.images,
10	10	org.eclipse.jface.internal.text;x-internal:=true,
11		org.eclipse.jface.internal.text.html;x-friends:="org.eclipse.ui.workbench.texteditor, org.eclipse.ui.editors, org.eclipse.jdt.debug.ui, org.eclipse.jdt.ui, org.eclipse.ant.ui, org.eclipse.ltk.ui.refactoring, org.eclipse.pde.ui",
	11	org.eclipse.jface.internal.text.codemining;x-internal:=true,
	12	org.eclipse.jface.internal.text.html;x-friends:="org.eclipse.ui.workbench.texteditor, org.eclipse.ui.editors, org.eclipse.jdt.debug.ui, org.eclipse.jdt.ui, org.eclipse.ant.ui, org.eclipse.ltk.ui.refactoring, org.eclipse.pde.ui, org.eclipse.xtext.ui",
12	13	org.eclipse.jface.internal.text.link.contentassist;x-internal:=true,
13	14	org.eclipse.jface.internal.text.revisions;x-internal:=true,
14	15	org.eclipse.jface.internal.text.source;x-internal:=true,
15	16	org.eclipse.jface.text,
	17	org.eclipse.jface.text.codemining,
16	18	org.eclipse.jface.text.contentassist,
17	19	org.eclipse.jface.text.formatter,
18	20	org.eclipse.jface.text.hyperlink,

24	26	org.eclipse.jface.text.revisions,
25	27	org.eclipse.jface.text.rules,
26	28	org.eclipse.jface.text.source,
	29	org.eclipse.jface.text.source.inlined,
27	30	org.eclipse.jface.text.source.projection,
28	31	org.eclipse.jface.text.source.projection.images,
29	32	org.eclipse.jface.text.templates,

31	34	Require-Bundle:
32	35	org.eclipse.core.runtime;bundle-version="[3.5.0,4.0.0)",
33	36	org.eclipse.text;bundle-version="[3.5.0,4.0.0)";visibility:=reexport,
34		org.eclipse.swt;bundle-version="[3.103.0,4.0.0)",
	37	org.eclipse.swt;bundle-version="[3.107.0,4.0.0)",
35	38	org.eclipse.jface;bundle-version="[3.5.0,4.0.0)"
36	39	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
37	40	Import-Package: com.ibm.icu.text
	41	Automatic-Module-Name: org.eclipse.jface.text

+2

-1

org.eclipse.jface.text/forceQualifierUpdate.txt less more

0	0	Bug 510796 - Comparator errors in I20170120-2000
1		Bug 511251 - Comparator errors in I20170127-2200⏎
	1	Bug 511251 - Comparator errors in I20170127-2200
	2	Bug 521182 - [compiler] method reference on null object should throw NPE at runtime (JLS compliance)⏎

+2

-2

org.eclipse.jface.text/pom.xml less more

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<groupId>org.eclipse.jface</groupId>
19	19	<artifactId>org.eclipse.jface.text</artifactId>
20		<version>3.12.2-SNAPSHOT</version>
	20	<version>3.13.0-SNAPSHOT</version>
21	21	<packaging>eclipse-plugin</packaging>
22	22	</project>

+4

-4

org.eclipse.jface.text/projection/org/eclipse/jface/text/source/projection/ProjectionSummary.java less more

14	14	import java.util.Iterator;
15	15	import java.util.List;
16	16	import java.util.Map;
	17	import java.util.Map.Entry;
17	18
18	19	import org.eclipse.core.runtime.IProgressMonitor;
19	20	import org.eclipse.core.runtime.NullProgressMonitor;

221	222	if (!isCanceled(monitor))
222	223	extension.replaceAnnotations(null, additions);
223	224	} else {
224		Iterator<Annotation> e1= additions.keySet().iterator();
225		while (e1.hasNext()) {
226		AnnotationBag bag= (AnnotationBag) e1.next();
227		Position position= additions.get(bag);
	225	for (Entry<Annotation, Position> entry : additions.entrySet()) {
	226	AnnotationBag bag= (AnnotationBag) entry.getKey();
	227	Position position= entry.getValue();
228	228	if (isCanceled(monitor))
229	229	return;
230	230	visualAnnotationModel.addAnnotation(bag, position);

org.eclipse.jface.text/projection/org/eclipse/jface/text/source/projection/images/collapsed.png less more

Binary diff not shown

org.eclipse.jface.text/projection/org/eclipse/jface/text/source/projection/images/collapsed@2x.png less more

Binary diff not shown

org.eclipse.jface.text/projection/org/eclipse/jface/text/source/projection/images/expanded.png less more

Binary diff not shown

org.eclipse.jface.text/projection/org/eclipse/jface/text/source/projection/images/expanded@2x.png less more

Binary diff not shown

+1

-1

org.eclipse.jface.text/src/org/eclipse/jface/contentassist/AbstractControlContentAssistSubjectAdapter.java less more

237	237	* @param ve the verify event
238	238	*/
239	239	private void dump(String who, Event e, VerifyEvent ve) {
240		StringBuffer sb= new StringBuffer("--- [AbstractControlContentAssistSubjectAdapter]\n"); //$NON-NLS-1$
	240	StringBuilder sb= new StringBuilder("--- [AbstractControlContentAssistSubjectAdapter]\n"); //$NON-NLS-1$
241	241	sb.append(who);
242	242	sb.append(" - e: keyCode="+e.keyCode+hex(e.keyCode)); //$NON-NLS-1$
243	243	sb.append("; character="+e.character+hex(e.character)); //$NON-NLS-1$

+3

-3

org.eclipse.jface.text/src/org/eclipse/jface/contentassist/ComboContentAssistSubjectAdapter.java less more

179	179	@Override
180	180	public void removeSelectionListener(SelectionListener selectionListener) {
181	181	fCombo.removeSelectionListener(selectionListener);
182		Object listener= fModifyListeners.get(selectionListener);
183		if (listener instanceof Listener)
184		fCombo.removeListener(SWT.Modify, (Listener)listener);
	182	Listener listener= fModifyListeners.get(selectionListener);
	183	if (listener != null)
	184	fCombo.removeListener(SWT.Modify, listener);
185	185	}
186	186	}

+3

-3

org.eclipse.jface.text/src/org/eclipse/jface/contentassist/TextContentAssistSubjectAdapter.java less more

159	159	@Override
160	160	public void removeSelectionListener(SelectionListener selectionListener) {
161	161	fText.removeSelectionListener(selectionListener);
162		Object listener= fModifyListeners.get(selectionListener);
163		if (listener instanceof Listener)
164		fText.removeListener(SWT.Modify, (Listener)listener);
	162	Listener listener= fModifyListeners.get(selectionListener);
	163	if (listener != null)
	164	fText.removeListener(SWT.Modify, listener);
165	165	}
166	166	}

+3

-3

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/SelectionProcessor.java less more

301	301	@Override
302	302	String getText(ISelection selection) throws BadLocationException {
303	303	IBlockTextSelection cts= (IBlockTextSelection)selection;
304		StringBuffer buf= new StringBuffer(cts.getLength());
	304	StringBuilder buf= new StringBuilder(cts.getLength());
305	305	int startLine= cts.getStartLine();
306	306	int endLine= cts.getEndLine();
307	307	int startColumn= cts.getStartColumn();

470	470	return new ReplaceEdit(info.getOffset() + startColumn, endColumn - startColumn, replacement);
471	471	}
472	472
473		private void appendColumnRange(StringBuffer buf, int line, int visualStartColumn, int visualEndColumn) throws BadLocationException {
	473	private void appendColumnRange(StringBuilder buf, int line, int visualStartColumn, int visualEndColumn) throws BadLocationException {
474	474	IRegion info= fDocument.getLineInformation(line);
475	475	int lineLength= info.getLength();
476	476	String content= fDocument.get(info.getOffset(), lineLength);

542	542	gc= new GC(fStyledText);
543	543	int charWidth= gc.stringExtent(new String(Character.toString(character))).x;
544	544	int singleCharWidth= gc.stringExtent(" ").x; //$NON-NLS-1$
545		return (int)Math.ceil(charWidth / singleCharWidth);
	545	return (int) Math.ceil((double) charWidth / singleCharWidth);
546	546	} finally {
547	547	if (gc != null)
548	548	gc.dispose();

+34

-0

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CancellationExceptionMonitor.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide CodeMining support with CodeMiningManager - Bug 527720
	9	*/
	10	package org.eclipse.jface.internal.text.codemining;
	11
	12	import java.util.concurrent.CancellationException;
	13
	14	import org.eclipse.core.runtime.IProgressMonitor;
	15	import org.eclipse.core.runtime.NullProgressMonitor;
	16
	17	/**
	18	* {@link IProgressMonitor} which throws a {@link CancellationException} when
	19	* {@link IProgressMonitor#isCanceled()} returns true.
	20	*
	21	* @since 3.13
	22	*/
	23	class CancellationExceptionMonitor extends NullProgressMonitor {
	24
	25	@Override
	26	public boolean isCanceled() {
	27	boolean canceled= super.isCanceled();
	28	if (canceled) {
	29	throw new CancellationException();
	30	}
	31	return canceled;
	32	}
	33	}

+198

-0

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineContentAnnotation.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide CodeMining support with CodeMiningManager - Bug 527720
	9	*/
	10	package org.eclipse.jface.internal.text.codemining;
	11
	12	import java.util.ArrayList;
	13	import java.util.List;
	14	import java.util.function.Consumer;
	15
	16	import org.eclipse.swt.custom.StyledText;
	17	import org.eclipse.swt.events.MouseEvent;
	18	import org.eclipse.swt.graphics.Color;
	19	import org.eclipse.swt.graphics.GC;
	20	import org.eclipse.swt.graphics.Point;
	21	import org.eclipse.swt.graphics.Rectangle;
	22
	23	import org.eclipse.core.runtime.IProgressMonitor;
	24
	25	import org.eclipse.jface.text.Position;
	26	import org.eclipse.jface.text.codemining.ICodeMining;
	27	import org.eclipse.jface.text.source.ISourceViewer;
	28	import org.eclipse.jface.text.source.inlined.LineContentAnnotation;
	29
	30	/**
	31	* Code Mining annotation in line content.
	32	*
	33	* @since 3.13
	34	*/
	35	public class CodeMiningLineContentAnnotation extends LineContentAnnotation implements ICodeMiningAnnotation {
	36
	37	private static final String SEPARATOR= " \| "; //$NON-NLS-1$
	38
	39	/**
	40	* List of resolved minings which contains current resolved minings and last resolved minings
	41	* and null if mining is not resolved.
	42	*/
	43	private ICodeMining[] fResolvedMinings;
	44
	45	/**
	46	* List of current resolved/unresolved minings
	47	*/
	48	private final List<ICodeMining> fMinings;
	49
	50	/**
	51	* List of bounds minings
	52	*/
	53	private final List<Rectangle> fBounds;
	54
	55	/**
	56	* The current progress monitor
	57	*/
	58	private IProgressMonitor fMonitor;
	59
	60	/**
	61	* Code mining annotation constructor.
	62	*
	63	* @param position the position
	64	* @param viewer the viewer
	65	*/
	66	public CodeMiningLineContentAnnotation(Position position, ISourceViewer viewer) {
	67	super(position, viewer);
	68	fResolvedMinings= null;
	69	fMinings= new ArrayList<>();
	70	fBounds= new ArrayList<>();
	71	}
	72
	73	@Override
	74	public void update(List<ICodeMining> minings, IProgressMonitor monitor) {
	75	if (fResolvedMinings == null \|\| (fResolvedMinings.length != minings.size())) {
	76	// size of resolved minings are different from size of minings to update, initialize it with size of minings to update
	77	fResolvedMinings= new ICodeMining[minings.size()];
	78	}
	79	// fill valid resolved minings with old minings.
	80	int length= Math.min(fMinings.size(), minings.size());
	81	for (int i= 0; i < length; i++) {
	82	ICodeMining mining= fMinings.get(i);
	83	if (mining.getLabel() != null) {
	84	// mining was resolved without an error.
	85	fResolvedMinings[i]= mining;
	86	}
	87	}
	88	disposeMinings();
	89	fMonitor= monitor;
	90	fMinings.addAll(minings);
	91	}
	92
	93	@Override
	94	public void markDeleted(boolean deleted) {
	95	super.markDeleted(deleted);
	96	if (deleted) {
	97	disposeMinings();
	98	fResolvedMinings= null;
	99	}
	100	}
	101
	102	private void disposeMinings() {
	103	fMinings.stream().forEach(ICodeMining::dispose);
	104	fMinings.clear();
	105	}
	106
	107	@Override
	108	protected int drawAndComputeWidth(GC gc, StyledText textWidget, int offset, int length, Color color, int x, int y) {
	109	List<ICodeMining> minings= new ArrayList<>(fMinings);
	110	int nbDraw= 0;
	111	int originalX= x;
	112	int separatorWidth= -1;
	113	boolean redrawn= false;
	114	fBounds.clear();
	115	for (int i= 0; i < minings.size(); i++) {
	116	ICodeMining mining= minings.get(i);
	117	// try to get the last resolved mining.
	118	ICodeMining lastResolvedMining= (fResolvedMinings != null && fResolvedMinings.length > i) ? fResolvedMinings[i] : null;
	119	if (mining.getLabel() != null) {
	120	// mining is resolved without error, update the resolved mining list
	121	fResolvedMinings[i]= mining;
	122	} else if (!mining.isResolved()) {
	123	// the mining is not resolved, draw the last resolved mining
	124	mining= lastResolvedMining;
	125	if (!redrawn) {
	126	// redraw the annotation when mining is resolved.
	127	redraw();
	128	redrawn= true;
	129	}
	130	} else {
	131	// the mining is resolved with error, draw the last resolved mining
	132	mining= lastResolvedMining;
	133	}
	134	if (!CodeMiningManager.isValidMining(mining)) {
	135	// ignore the draw of mining
	136	continue;
	137	}
	138	// draw the mining
	139	if (nbDraw > 0) {
	140	initGC(textWidget, color, gc);
	141	gc.drawText(SEPARATOR, x, y);
	142	if (separatorWidth == -1) {
	143	separatorWidth= gc.stringExtent(SEPARATOR).x;
	144	}
	145	x+= separatorWidth;
	146	}
	147	initGC(textWidget, color, gc);
	148	@SuppressWarnings("null")
	149	Point loc= mining.draw(gc, textWidget, color, x, y);
	150	fBounds.add(new Rectangle(x, y, loc.x, loc.y));
	151	x+= loc.x;
	152	nbDraw++;
	153	}
	154	return x - originalX;
	155	}
	156
	157	/**
	158	* Initialize GC with given color and styled text background color and font.
	159	*
	160	* @param textWidget the text widget
	161	* @param color the color
	162	* @param gc the gc to initialize
	163	*/
	164	private void initGC(StyledText textWidget, Color color, GC gc) {
	165	gc.setForeground(color);
	166	gc.setBackground(textWidget.getBackground());
	167	gc.setFont(textWidget.getFont());
	168	}
	169
	170	@Override
	171	public void redraw() {
	172	// redraw codemining annotation is done only if all current minings are resolved.
	173	List<ICodeMining> minings= new ArrayList<>(fMinings);
	174	for (ICodeMining mining : minings) {
	175	if (!mining.isResolved()) {
	176	// one of mining is not resolved, resolve it and then redraw the annotation.
	177	mining.resolve(getViewer(), fMonitor).thenRunAsync(() -> {
	178	this.redraw();
	179	});
	180	return;
	181	}
	182	}
	183	// all minings are resolved, redraw the annotation
	184	super.redraw();
	185	}
	186
	187	@Override
	188	public Consumer<MouseEvent> getAction(MouseEvent e) {
	189	ICodeMining mining= CodeMiningManager.getValidCodeMiningAtLocation(fResolvedMinings, fBounds, e.x, e.y);
	190	return mining != null ? mining.getAction() : null;
	191	}
	192
	193	@Override
	194	public boolean isInVisibleLines() {
	195	return super.isInVisibleLines();
	196	}
	197	}

+215

-0

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineHeaderAnnotation.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide CodeMining support with CodeMiningManager - Bug 527720
	9	*/
	10	package org.eclipse.jface.internal.text.codemining;
	11
	12	import java.util.ArrayList;
	13	import java.util.List;
	14	import java.util.function.Consumer;
	15	import java.util.stream.Stream;
	16
	17	import org.eclipse.swt.custom.StyledText;
	18	import org.eclipse.swt.events.MouseEvent;
	19	import org.eclipse.swt.graphics.Color;
	20	import org.eclipse.swt.graphics.GC;
	21	import org.eclipse.swt.graphics.Point;
	22	import org.eclipse.swt.graphics.Rectangle;
	23
	24	import org.eclipse.core.runtime.IProgressMonitor;
	25
	26	import org.eclipse.jface.text.Position;
	27	import org.eclipse.jface.text.codemining.ICodeMining;
	28	import org.eclipse.jface.text.source.ISourceViewer;
	29	import org.eclipse.jface.text.source.inlined.LineHeaderAnnotation;
	30
	31	/**
	32	* Code Mining annotation in line header.
	33	*
	34	* @since 3.13
	35	*/
	36	public class CodeMiningLineHeaderAnnotation extends LineHeaderAnnotation implements ICodeMiningAnnotation {
	37
	38	private static final String SEPARATOR= " \| "; //$NON-NLS-1$
	39
	40	/**
	41	* List of resolved minings which contains current resolved minings and last resolved minings
	42	* and null if mining is not resolved.
	43	*/
	44	private ICodeMining[] fResolvedMinings;
	45
	46	/**
	47	* List of current resolved/unresolved minings
	48	*/
	49	private final List<ICodeMining> fMinings;
	50
	51	/**
	52	* List of bounds minings
	53	*/
	54	private final List<Rectangle> fBounds;
	55
	56	/**
	57	* The current progress monitor
	58	*/
	59	private IProgressMonitor fMonitor;
	60
	61	/**
	62	* Code mining annotation constructor.
	63	*
	64	* @param position the position
	65	* @param viewer the viewer
	66	*/
	67	public CodeMiningLineHeaderAnnotation(Position position, ISourceViewer viewer) {
	68	super(position, viewer);
	69	fResolvedMinings= null;
	70	fMinings= new ArrayList<>();
	71	fBounds= new ArrayList<>();
	72	}
	73
	74	@Override
	75	public int getHeight() {
	76	return hasAtLeastOneResolvedMiningNotEmpty() ? super.getHeight() : 0;
	77	}
	78
	79	/**
	80	* Returns <code>true</code> if the annotation has at least one resolved mining which have a
	81	* label and <code>false</code> otherwise.
	82	*
	83	* @return <code>true</code> if the annotation has at least one resolved mining which have a
	84	* label and <code>false</code> otherwise.
	85	*/
	86	private boolean hasAtLeastOneResolvedMiningNotEmpty() {
	87	if (fResolvedMinings == null \|\| fResolvedMinings.length == 0) {
	88	return false;
	89	}
	90	return Stream.of(fResolvedMinings).anyMatch(m -> CodeMiningManager.isValidMining(m));
	91	}
	92
	93	@Override
	94	public void update(List<ICodeMining> minings, IProgressMonitor monitor) {
	95	if (fResolvedMinings == null \|\| (fResolvedMinings.length != minings.size())) {
	96	// size of resolved minings are different from size of minings to update, initialize it with size of minings to update
	97	fResolvedMinings= new ICodeMining[minings.size()];
	98	}
	99	// fill valid resolved minings with old minings.
	100	int length= Math.min(fMinings.size(), minings.size());
	101	for (int i= 0; i < length; i++) {
	102	ICodeMining mining= fMinings.get(i);
	103	if (mining.getLabel() != null) {
	104	fResolvedMinings[i]= mining;
	105	}
	106	}
	107	disposeMinings();
	108	fMonitor= monitor;
	109	fMinings.addAll(minings);
	110	}
	111
	112	@Override
	113	public void markDeleted(boolean deleted) {
	114	super.markDeleted(deleted);
	115	if (deleted) {
	116	disposeMinings();
	117	fResolvedMinings= null;
	118	}
	119	}
	120
	121	private void disposeMinings() {
	122	fMinings.stream().forEach(ICodeMining::dispose);
	123	fMinings.clear();
	124	}
	125
	126	@Override
	127	public void draw(GC gc, StyledText textWidget, int offset, int length, Color color, int x, int y) {
	128	List<ICodeMining> minings= new ArrayList<>(fMinings);
	129	int nbDraw= 0;
	130	int separatorWidth= -1;
	131	boolean redrawn= false;
	132	fBounds.clear();
	133	for (int i= 0; i < minings.size(); i++) {
	134	ICodeMining mining= minings.get(i);
	135	// try to get the last resolved mining.
	136	ICodeMining lastResolvedMining= (fResolvedMinings != null && fResolvedMinings.length > i) ? fResolvedMinings[i] : null;
	137	if (mining.getLabel() != null) {
	138	// mining is resolved without error, update the resolved mining list
	139	fResolvedMinings[i]= mining;
	140	} else if (!mining.isResolved()) {
	141	// the mining is not resolved, draw the last resolved mining
	142	mining= lastResolvedMining;
	143	if (!redrawn) {
	144	// redraw the annotation when mining is resolved.
	145	redraw();
	146	redrawn= true;
	147	}
	148	} else {
	149	// the mining is resolved with error, draw the last resolved mining
	150	mining= lastResolvedMining;
	151	}
	152	if (!CodeMiningManager.isValidMining(mining)) {
	153	// ignore the draw of mining
	154	continue;
	155	}
	156	// draw the mining
	157	if (nbDraw > 0) {
	158	initGC(textWidget, color, gc);
	159	gc.drawText(SEPARATOR, x, y);
	160	if (separatorWidth == -1) {
	161	separatorWidth= gc.stringExtent(SEPARATOR).x;
	162	}
	163	x+= separatorWidth;
	164	}
	165	initGC(textWidget, color, gc);
	166	@SuppressWarnings("null")
	167	Point loc= mining.draw(gc, textWidget, color, x, y);
	168	fBounds.add(new Rectangle(x, y, loc.x, loc.y));
	169	x+= loc.x;
	170	nbDraw++;
	171	}
	172	}
	173
	174	/**
	175	* Initialize GC with given color and styled text background color and font.
	176	*
	177	* @param textWidget the text widget
	178	* @param color the color
	179	* @param gc the gc to initialize
	180	*/
	181	private void initGC(StyledText textWidget, Color color, GC gc) {
	182	gc.setForeground(color);
	183	gc.setBackground(textWidget.getBackground());
	184	gc.setFont(textWidget.getFont());
	185	}
	186
	187	@Override
	188	public void redraw() {
	189	// redraw codemining annotation is done only if all current minings are resolved.
	190	List<ICodeMining> minings= new ArrayList<>(fMinings);
	191	for (ICodeMining mining : minings) {
	192	if (!mining.isResolved()) {
	193	// one of mining is not resolved, resolve it and then redraw the annotation.
	194	mining.resolve(getViewer(), fMonitor).thenRunAsync(() -> {
	195	this.redraw();
	196	});
	197	return;
	198	}
	199	}
	200	// all minings are resolved, redraw the annotation
	201	super.redraw();
	202	}
	203
	204	@Override
	205	public Consumer<MouseEvent> getAction(MouseEvent e) {
	206	ICodeMining mining= CodeMiningManager.getValidCodeMiningAtLocation(fResolvedMinings, fBounds, e.x, e.y);
	207	return mining != null ? mining.getAction() : null;
	208	}
	209
	210	@Override
	211	public boolean isInVisibleLines() {
	212	return super.isInVisibleLines();
	213	}
	214	}

+287

-0

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningManager.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide CodeMining support with CodeMiningManager - Bug 527720
	9	*/
	10	package org.eclipse.jface.internal.text.codemining;
	11
	12	import java.util.Arrays;
	13	import java.util.Collections;
	14	import java.util.HashSet;
	15	import java.util.LinkedHashMap;
	16	import java.util.List;
	17	import java.util.Map;
	18	import java.util.Set;
	19	import java.util.concurrent.CompletableFuture;
	20	import java.util.function.Function;
	21	import java.util.stream.Collectors;
	22
	23	import org.eclipse.swt.graphics.Rectangle;
	24
	25	import org.eclipse.core.runtime.Assert;
	26	import org.eclipse.core.runtime.IProgressMonitor;
	27
	28	import org.eclipse.jface.text.IDocument;
	29	import org.eclipse.jface.text.ITextViewer;
	30	import org.eclipse.jface.text.Position;
	31	import org.eclipse.jface.text.codemining.ICodeMining;
	32	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
	33	import org.eclipse.jface.text.codemining.LineHeaderCodeMining;
	34	import org.eclipse.jface.text.source.ISourceViewer;
	35	import org.eclipse.jface.text.source.inlined.AbstractInlinedAnnotation;
	36	import org.eclipse.jface.text.source.inlined.InlinedAnnotationSupport;
	37
	38	/**
	39	* Code Mining manager implementation.
	40	*
	41	* @since 3.13
	42	*/
	43	public class CodeMiningManager implements Runnable {
	44
	45	/**
	46	* The source viewer
	47	*/
	48	private final ISourceViewer fViewer;
	49
	50	/**
	51	* The inlined annotation support used to draw CodeMining in the line spacing.
	52	*/
	53	private final InlinedAnnotationSupport fInlinedAnnotationSupport;
	54
	55	/**
	56	* The list of codemining providers.
	57	*/
	58	private List<ICodeMiningProvider> fCodeMiningProviders;
	59
	60	/**
	61	* The current progress monitor.
	62	*/
	63	private IProgressMonitor fMonitor;
	64
	65	/**
	66	* Constructor of codemining manager with the given arguments.
	67	*
	68	* @param viewer the source viewer
	69	* @param inlinedAnnotationSupport the inlined annotation support used to draw code minings
	70	* @param codeMiningProviders the array of codemining providers, must not be empty
	71	*/
	72	public CodeMiningManager(ISourceViewer viewer, InlinedAnnotationSupport inlinedAnnotationSupport,
	73	ICodeMiningProvider[] codeMiningProviders) {
	74	Assert.isNotNull(viewer);
	75	Assert.isNotNull(inlinedAnnotationSupport);
	76	Assert.isNotNull(codeMiningProviders);
	77	fViewer= viewer;
	78	fInlinedAnnotationSupport= inlinedAnnotationSupport;
	79	setCodeMiningProviders(codeMiningProviders);
	80	}
	81
	82	/**
	83	* Set the codemining providers.
	84	*
	85	* @param codeMiningProviders the codemining providers.
	86	*/
	87	public void setCodeMiningProviders(ICodeMiningProvider[] codeMiningProviders) {
	88	fCodeMiningProviders= Arrays.asList(codeMiningProviders);
	89	}
	90
	91	/**
	92	* Uninstalls this codemining manager.
	93	*/
	94	public void uninstall() {
	95	cancel();
	96	}
	97
	98	/**
	99	* Collect, resolve and render the code minings of the viewer.
	100	*/
	101	@Override
	102	public void run() {
	103	if (fViewer == null \|\| fInlinedAnnotationSupport == null \|\| fCodeMiningProviders == null
	104	\|\| fCodeMiningProviders.size() == 0 \|\| fViewer.getAnnotationModel() == null) {
	105	return;
	106	}
	107	// Cancel the last progress monitor to cancel last resolve and render of code
	108	// minings
	109	cancel();
	110	// Update the code minings
	111	updateCodeMinings();
	112	}
	113
	114	/**
	115	* Update the code minings.
	116	*/
	117	private void updateCodeMinings() {
	118	// Refresh the code minings by using the new progress monitor.
	119	fMonitor= new CancellationExceptionMonitor();
	120	IProgressMonitor monitor= fMonitor;
	121	// Collect the code minings for the viewer
	122	getCodeMinings(fViewer, fCodeMiningProviders, monitor).thenAccept(symbols -> {
	123	// check if request was canceled.
	124	monitor.isCanceled();
	125	// then group code minings by lines position
	126	Map<Position, List<ICodeMining>> groups= groupByLines(symbols, fCodeMiningProviders);
	127	// resolve and render code minings
	128	renderCodeMinings(groups, fViewer, monitor);
	129	});
	130	}
	131
	132	/**
	133	* Cancel the codemining process.
	134	*/
	135	private void cancel() {
	136	// Cancel the last progress monitor.
	137	if (fMonitor != null) {
	138	fMonitor.setCanceled(true);
	139	}
	140	}
	141
	142	/**
	143	* Return the list of {@link CompletableFuture} which provides the list of {@link ICodeMining}
	144	* for the given <code>viewer</code> by using the given providers.
	145	*
	146	* @param viewer the text viewer.
	147	* @param providers the CodeMining list providers.
	148	* @param monitor the progress monitor.
	149	* @return the list of {@link CompletableFuture} which provides the list of {@link ICodeMining}
	150	* for the given <code>viewer</code> by using the given providers.
	151	*/
	152	private static CompletableFuture<List<? extends ICodeMining>> getCodeMinings(ITextViewer viewer,
	153	List<ICodeMiningProvider> providers, IProgressMonitor monitor) {
	154	List<CompletableFuture<List<? extends ICodeMining>>> com= providers.stream()
	155	.map(provider -> provider.provideCodeMinings(viewer, monitor)).filter(c -> c != null)
	156	.collect(Collectors.toList());
	157	return CompletableFuture.allOf(com.toArray(new CompletableFuture[com.size()])).thenApply(
	158	v -> com.stream().map(CompletableFuture::join).flatMap(l -> l.stream()).collect(Collectors.toList()));
	159	}
	160
	161	/**
	162	* Returns a sorted Map which groups the given code minings by same position line.
	163	*
	164	* @param codeMinings list of code minings to group.
	165	* @param providers CodeMining providers used to retrieve code minings.
	166	* @return a sorted Map which groups the given code minings by same position line.
	167	*/
	168	private static Map<Position, List<ICodeMining>> groupByLines(List<? extends ICodeMining> codeMinings,
	169	List<ICodeMiningProvider> providers) {
	170	// sort code minings by lineNumber and provider-rank if
	171	Collections.sort(codeMinings, (a, b) -> {
	172	if (a.getPosition().offset < b.getPosition().offset) {
	173	return -1;
	174	} else if (a.getPosition().offset > b.getPosition().offset) {
	175	return 1;
	176	} else if (providers.indexOf(a.getProvider()) < providers.indexOf(b.getProvider())) {
	177	return -1;
	178	} else if (providers.indexOf(a.getProvider()) > providers.indexOf(b.getProvider())) {
	179	return 1;
	180	} else {
	181	return 0;
	182	}
	183	});
	184	return codeMinings.stream().collect(Collectors.groupingBy(ICodeMining::getPosition, LinkedHashMap::new,
	185	Collectors.mapping(Function.identity(), Collectors.toList())));
	186	}
	187
	188	/**
	189	* Render the codemining grouped by line position.
	190	*
	191	* @param groups code minings grouped by lines position
	192	* @param viewer the viewer
	193	* @param monitor the progress monitor
	194	*/
	195	private void renderCodeMinings(Map<Position, List<ICodeMining>> groups, ISourceViewer viewer,
	196	IProgressMonitor monitor) {
	197	// check if request was canceled.
	198	monitor.isCanceled();
	199	IDocument document= viewer != null ? viewer.getDocument() : null;
	200	if (document == null) {
	201	// this case comes from when editor is closed before codemining rendered is
	202	// done.
	203	return;
	204	}
	205	Set<ICodeMiningAnnotation> annotationsToRedraw= new HashSet<>();
	206	Set<AbstractInlinedAnnotation> currentAnnotations= new HashSet<>();
	207	// Loop for grouped code minings
	208	groups.entrySet().stream().forEach(g -> {
	209	// check if request was canceled.
	210	monitor.isCanceled();
	211
	212	Position pos= new Position(g.getKey().offset, g.getKey().length);
	213	List<ICodeMining> minings= g.getValue();
	214	boolean inLineHeader= minings.size() > 0 ? (minings.get(0) instanceof LineHeaderCodeMining) : true;
	215	// Try to find existing annotation
	216	AbstractInlinedAnnotation ann= fInlinedAnnotationSupport.findExistingAnnotation(pos);
	217	if (ann == null) {
	218	// The annotation doesn't exists, create it.
	219	ann= inLineHeader ? new CodeMiningLineHeaderAnnotation(pos, viewer) : new CodeMiningLineContentAnnotation(pos, viewer);
	220	} else if (ann instanceof ICodeMiningAnnotation && ((ICodeMiningAnnotation) ann).isInVisibleLines()) {
	221	// annotation is in visible lines
	222	annotationsToRedraw.add((ICodeMiningAnnotation) ann);
	223	}
	224	((ICodeMiningAnnotation) ann).update(minings, monitor);
	225	currentAnnotations.add(ann);
	226	});
	227	// check if request was canceled.
	228	monitor.isCanceled();
	229	fInlinedAnnotationSupport.updateAnnotations(currentAnnotations);
	230	// redraw the existing codemining annotations since their content can change
	231	annotationsToRedraw.stream().forEach(ann -> ann.redraw());
	232	}
	233
	234	/**
	235	* Returns <code>true</code> if the given mining has a non empty label and <code>false</code>
	236	* otherwise.
	237	*
	238	* @param mining the mining to check
	239	* @return <code>true</code> if the given mining has a non empty label and <code>false</code>
	240	* otherwise.
	241	*/
	242	static boolean isValidMining(ICodeMining mining) {
	243	return mining != null && mining.getLabel() != null && !mining.getLabel().isEmpty();
	244	}
	245
	246	/**
	247	* Returns the valid code mining at the given location by using the bounds of codemining
	248	* annotations which stores only the valid code mining.
	249	*
	250	* @param minings the list of mining of the codemining annotation.
	251	* @param bounds the bounds of the valid minings of the codemining annotation.
	252	* @param x the x location
	253	* @param y the y location
	254	* @return the valid code mining at the given location by using the bounds of codemining
	255	* annotations which stores only the valid code mining.
	256	*/
	257	static ICodeMining getValidCodeMiningAtLocation(ICodeMining[] minings, List<Rectangle> bounds, int x, int y) {
	258	for (int i= 0; i < bounds.size(); i++) {
	259	Rectangle bound= bounds.get(i);
	260	if (bound.contains(x, y)) {
	261	return getCodeValidMiningAtIndex(minings, i);
	262	}
	263	}
	264	return null;
	265	}
	266
	267	/**
	268	* Returns the valid code mining at the given index.
	269	*
	270	* @param minings the list of minings
	271	* @param index the index
	272	* @return the valid code mining at the given index.
	273	*/
	274	private static ICodeMining getCodeValidMiningAtIndex(ICodeMining[] minings, int index) {
	275	int validIndex= 0;
	276	for (ICodeMining mining : minings) {
	277	if (isValidMining(mining)) {
	278	if (validIndex == index) {
	279	return mining;
	280	}
	281	validIndex++;
	282	}
	283	}
	284	return null;
	285	}
	286	}

+46

-0

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/ICodeMiningAnnotation.java less more

	0	/**
	1	* Copyright (c) 2018, Angelo ZERR and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] CodeMining should support line header/content annotation type both - Bug 529115
	9	*/
	10	package org.eclipse.jface.internal.text.codemining;
	11
	12	import java.util.List;
	13
	14	import org.eclipse.core.runtime.IProgressMonitor;
	15
	16	import org.eclipse.jface.text.codemining.ICodeMining;
	17
	18	/**
	19	* Internal Code Mining annotation API used by the {@link CodeMiningManager}.
	20	*
	21	* @since 3.13
	22	*/
	23	public interface ICodeMiningAnnotation {
	24
	25	/**
	26	* Update code minings.
	27	*
	28	* @param minings the minings to update.
	29	* @param monitor the monitor
	30	*/
	31	void update(List<ICodeMining> minings, IProgressMonitor monitor);
	32
	33	/**
	34	* Redraw the codemining annotation.
	35	*/
	36	void redraw();
	37
	38	/**
	39	* Return whether the annotation is in visible lines.
	40	*
	41	* @return <code>true</code> if the annotation is in visible lines and <code>false</code>
	42	* otherwise.
	43	*/
	44	boolean isInVisibleLines();
	45	}

+3

-3

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/html/BrowserInformationControl.java less more

270	270	*/
271	271	@Override
272	272	public void setInput(Object input) {
273		Assert.isLegal(input == null \|\| input instanceof String \|\| input instanceof BrowserInformationControlInput);
	273	Assert.isLegal(input == null \|\| input instanceof String \|\| input instanceof BrowserInformationControlInput, input != null ? input.getClass().getName() : "null"); //$NON-NLS-1$
274	274
275	275	if (input instanceof String) {
276	276	setInformation((String)input);

305	305	else
306	306	styles= new String[] { "overflow:scroll;" }; //$NON-NLS-1$
307	307
308		StringBuffer buffer= new StringBuffer(content);
	308	StringBuilder buffer= new StringBuilder(content);
309	309	HTMLPrinter.insertStyles(buffer, styles);
310	310	content= buffer.toString();
311	311

589	589	return null;
590	590
591	591	GC gc= new GC(fBrowser);
592		Font font= fSymbolicFontName == null ? JFaceResources.getDialogFont() : JFaceResources.getFont(fSymbolicFontName);
	592	Font font= JFaceResources.getFont(fSymbolicFontName);
593	593	gc.setFont(font);
594	594	int width= gc.getFontMetrics().getAverageCharWidth();
595	595	int height= gc.getFontMetrics().getHeight();

+7

-7

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/html/HTML2TextReader.java less more

152	152	fCurrentStyleRange.strikeout= false;
153	153	}
154	154	}
155
	155
156	156	private void finishAndReinitializeCurrentStyle(int offset) {
157	157	if (fTextPresentation != null && offset != fCurrentStyleRange.start && !isDefaultStyleRange(fCurrentStyleRange)) {
158	158	fCurrentStyleRange.length= offset - fCurrentStyleRange.start;

218	218	startItalic();
219	219	return EMPTY_STRING;
220	220	}
221
	221
222	222	if ("/i".equals(html) \|\| "/em".equals(html)) { //$NON-NLS-1$ //$NON-NLS-2$
223	223	stopItalic();
224	224	return EMPTY_STRING;
225	225	}
226
	226
227	227	if ("b".equals(html) \|\| "strong".equals(html)) { //$NON-NLS-1$ //$NON-NLS-2$
228	228	startBold();
229	229	return EMPTY_STRING;

300	300	*/
301	301	private String processHTMLTag() throws IOException {
302	302
303		StringBuffer buf= new StringBuffer();
	303	StringBuilder buf= new StringBuilder();
304	304	int ch;
305	305	do {
306	306

336	336	return html2Text(buf.toString());
337	337	}
338	338
339		private static boolean isInComment(StringBuffer buf) {
	339	private static boolean isInComment(StringBuilder buf) {
340	340	return buf.length() >= 3 && "!--".equals(buf.substring(0, 3)); //$NON-NLS-1$
341	341	}
342	342
343		private static boolean isCommentEnd(StringBuffer buf) {
	343	private static boolean isCommentEnd(StringBuilder buf) {
344	344	int tagLen= buf.length();
345	345	return tagLen >= 5 && "--".equals(buf.substring(tagLen - 2)); //$NON-NLS-1$
346	346	}

374	374	* A '&' has been read. Process a entity
375	375	*/
376	376	private String processEntity() throws IOException {
377		StringBuffer buf= new StringBuffer();
	377	StringBuilder buf= new StringBuilder();
378	378	int ch= nextChar();
379	379	while (Character.isLetterOrDigit((char)ch) \|\| ch == '#') {
380	380	buf.append((char) ch);

+498

-22

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/html/HTMLPrinter.java less more

15	15
16	16	import org.eclipse.swt.SWT;
17	17	import org.eclipse.swt.SWTError;
	18	import org.eclipse.swt.graphics.Color;
18	19	import org.eclipse.swt.graphics.FontData;
19	20	import org.eclipse.swt.graphics.RGB;
20	21	import org.eclipse.swt.widgets.Display;
21		import org.eclipse.swt.widgets.Event;
22		import org.eclipse.swt.widgets.Listener;
23	22
24	23	import org.eclipse.jface.resource.JFaceColors;
	24	import org.eclipse.jface.resource.JFaceResources;
25	25	import org.eclipse.jface.util.Util;
26	26
27	27	import org.eclipse.jface.text.DefaultInformationControl;

35	35
36	36	private static volatile RGB BG_COLOR_RGB= new RGB(255, 255, 225); // RGB value of info bg color on WindowsXP
37	37	private static volatile RGB FG_COLOR_RGB= new RGB(0, 0, 0); // RGB value of info fg color on WindowsXP
	38	private static volatile RGB LINK_COLOR_RGB= new RGB(0, 0, 255); // dark blue
	39	private static volatile RGB ACTIVE_LINK_COLOR_RGB= new RGB(0, 0, 128); // light blue
38	40
39	41	private static final String UNIT; // See https://bugs.eclipse.org/bugs/show_bug.cgi?id=155993
40	42	static {

67	69	private static void cacheColors(Display display) {
68	70	BG_COLOR_RGB= JFaceColors.getInformationViewerBackgroundColor(display).getRGB();
69	71	FG_COLOR_RGB= JFaceColors.getInformationViewerForegroundColor(display).getRGB();
	72	Color hyperlinkText= JFaceColors.getHyperlinkText(display);
	73	if (hyperlinkText != null) {
	74	LINK_COLOR_RGB= hyperlinkText.getRGB();
	75	}
	76	Color activeHyperlinkText= JFaceColors.getActiveHyperlinkText(display);
	77	if (activeHyperlinkText != null) {
	78	ACTIVE_LINK_COLOR_RGB= activeHyperlinkText.getRGB();
	79	}
70	80	}
71	81
72	82	private static void installColorUpdater(final Display display) {
73		display.addListener(SWT.Settings, new Listener() {
74		@Override
75		public void handleEvent(Event event) {
76		cacheColors(display);
77		}
78		});
	83	display.addListener(SWT.Settings, event -> cacheColors(display));
	84	JFaceResources.getColorRegistry().addListener(event -> cacheColors(display));
79	85	}
80	86
81	87	private static String replace(String text, char c, String s) {

86	92	if (current == -1)
87	93	return text;
88	94
89		StringBuffer buffer= new StringBuffer();
	95	StringBuilder buffer= new StringBuilder();
90	96	while (current > -1) {
91	97	buffer.append(text.substring(previous, current));
92	98	buffer.append(s);

107	113	* @return the string with escaped characters
108	114	*
109	115	* @see #convertToHTMLContentWithWhitespace(String) for use in browsers
110		* @see #addPreFormatted(StringBuffer, String) for rendering with an {@link HTML2TextReader}
	116	* @see #addPreFormatted(StringBuilder, String) for rendering with an {@link HTML2TextReader}
111	117	*/
112	118	public static String convertToHTMLContent(String content) {
113	119	content= replace(content, '&', "&"); //$NON-NLS-1$

117	123	}
118	124
119	125	/**
120		* Escapes reserved HTML characters in the given string
121		* and returns them in a way that preserves whitespace in a browser.
	126	* Escapes reserved HTML characters in the given string and returns them in a way that preserves
	127	* whitespace in a browser.
122	128	* <p>
123		* <b>Warning:</b> Whitespace will not be preserved when rendered with an {@link HTML2TextReader}
124		* (e.g. in a {@link DefaultInformationControl} that renders simple HTML).
125
	129	* <b>Warning:</b> Whitespace will not be preserved when rendered with an
	130	* {@link HTML2TextReader} (e.g. in a {@link DefaultInformationControl} that renders simple
	131	* HTML).
	132	*
126	133	* @param content the input string
127	134	* @return the processed string
128	135	*
129		* @see #addPreFormatted(StringBuffer, String)
	136	* @see #addPreFormatted(StringBuilder, String)
130	137	* @see #convertToHTMLContent(String)
131	138	* @since 3.7
132	139	*/

140	147
141	148	public static String read(Reader rd) {
142	149
143		StringBuffer buffer= new StringBuffer();
	150	StringBuilder buffer= new StringBuilder();
144	151	char[] readBuffer= new char[2048];
145	152
146	153	try {

156	163	return null;
157	164	}
158	165
	166	/**
	167	*
	168	* @deprecated migrate to new StringBuilder API
	169	*
	170	* @param buffer the output StringBuilder
	171	* @param position offset where the prolog is placed
	172	* @param fgRGB Foreground-Color
	173	* @param bgRGB Background-Color
	174	* @param styleSheet Stylesheet
	175	*/
	176	@Deprecated
159	177	public static void insertPageProlog(StringBuffer buffer, int position, RGB fgRGB, RGB bgRGB, String styleSheet) {
160	178	if (fgRGB == null)
161	179	fgRGB= FG_COLOR_RGB;

170	188
171	189	appendColors(pageProlog, fgRGB, bgRGB);
172	190
	191	buffer.insert(position, pageProlog.toString());
	192	}
	193
	194	/**
	195	*
	196	* @param buffer the output StringBuilder
	197	* @param position offset where the prolog is placed
	198	* @param fgRGB Foreground-Color
	199	* @param bgRGB Background-Color
	200	* @param styleSheet Stylesheet
	201	*/
	202	public static void insertPageProlog(StringBuilder buffer, int position, RGB fgRGB, RGB bgRGB, String styleSheet) {
	203	if (fgRGB == null)
	204	fgRGB= FG_COLOR_RGB;
	205	if (bgRGB == null)
	206	bgRGB= BG_COLOR_RGB;
	207
	208	StringBuilder pageProlog= new StringBuilder(300);
	209
	210	pageProlog.append("<html>"); //$NON-NLS-1$
	211
	212	appendStyleSheet(pageProlog, styleSheet, fgRGB, bgRGB);
	213
	214	appendColors(pageProlog, fgRGB, bgRGB);
	215
173	216	buffer.insert(position, pageProlog.toString());
174	217	}
175	218
	219	/**
	220	*
	221	*
	222	* @param pageProlog The Pageprolog where the color has to be set
	223	* @param fgRGB Foreground-Color
	224	* @param bgRGB Background-Color
	225	*
	226	*/
	227	private static void appendColors(StringBuilder pageProlog, RGB fgRGB, RGB bgRGB) {
	228	pageProlog.append("<body text=\""); //$NON-NLS-1$
	229	appendColor(pageProlog, fgRGB);
	230	pageProlog.append("\" bgcolor=\""); //$NON-NLS-1$
	231	appendColor(pageProlog, bgRGB);
	232	pageProlog.append("\">"); //$NON-NLS-1$
	233	}
	234
	235	/**
	236	*
	237	*
	238	* @param pageProlog The Pageprolog where the color has to be set
	239	* @param fgRGB Foreground-Color
	240	* @param bgRGB Background-Color
	241	*
	242	* @deprecated migrate to new StringBuilder API
	243	*/
	244	@Deprecated
176	245	private static void appendColors(StringBuffer pageProlog, RGB fgRGB, RGB bgRGB) {
177	246	pageProlog.append("<body text=\""); //$NON-NLS-1$
178	247	appendColor(pageProlog, fgRGB);

181	250	pageProlog.append("\">"); //$NON-NLS-1$
182	251	}
183	252
	253	/**
	254	*
	255	*
	256	* @param buffer The Output buffer
	257	* @param rgb RGB-Value
	258	*
	259	*/
	260	private static void appendColor(StringBuilder buffer, RGB rgb) {
	261	buffer.append('#');
	262	appendAsHexString(buffer, rgb.red);
	263	appendAsHexString(buffer, rgb.green);
	264	appendAsHexString(buffer, rgb.blue);
	265	}
	266
	267	/**
	268	*
	269	*
	270	* @param buffer The Output buffer
	271	* @param rgb RGB-Value
	272	*
	273	* @deprecated migrate to new StringBuilder API
	274	*/
	275	@Deprecated
184	276	private static void appendColor(StringBuffer buffer, RGB rgb) {
185	277	buffer.append('#');
186	278	appendAsHexString(buffer, rgb.red);

188	280	appendAsHexString(buffer, rgb.blue);
189	281	}
190	282
	283	/**
	284	*
	285	* @param buffer the output buffer
	286	* @param intValue the intValue will be converted to hex and appended
	287	*
	288	*/
	289	private static void appendAsHexString(StringBuilder buffer, int intValue) {
	290	String hexValue= Integer.toHexString(intValue);
	291	if (hexValue.length() == 1)
	292	buffer.append('0');
	293	buffer.append(hexValue);
	294	}
	295
	296	/**
	297	*
	298	* @param buffer the output buffer
	299	* @param intValue the intValue will be converted to hex and appended
	300	*
	301	* @deprecated migrate to new StringBuilder API
	302	*/
	303	@Deprecated
191	304	private static void appendAsHexString(StringBuffer buffer, int intValue) {
192	305	String hexValue= Integer.toHexString(intValue);
193	306	if (hexValue.length() == 1)

195	308	buffer.append(hexValue);
196	309	}
197	310
	311	/**
	312	*
	313	* @param buffer the output buffer
	314	* @param styles array with styles to be appended
	315	*
	316	*/
	317	public static void insertStyles(StringBuilder buffer, String[] styles) {
	318	if (styles == null \|\| styles.length == 0)
	319	return;
	320
	321	StringBuilder styleBuf= new StringBuilder(10 * styles.length);
	322	for (String style : styles) {
	323	styleBuf.append(" style=\""); //$NON-NLS-1$
	324	styleBuf.append(style);
	325	styleBuf.append('"');
	326	}
	327
	328	// Find insertion index
	329	// a) within existing body tag with trailing space
	330	int index= buffer.indexOf("<body "); //$NON-NLS-1$
	331	if (index != -1) {
	332	buffer.insert(index+5, styleBuf);
	333	return;
	334	}
	335
	336	// b) within existing body tag without attributes
	337	index= buffer.indexOf("<body>"); //$NON-NLS-1$
	338	if (index != -1) {
	339	buffer.insert(index+5, ' ');
	340	buffer.insert(index+6, styleBuf);
	341	return;
	342	}
	343	}
	344
	345
	346	/**
	347	*
	348	* @param buffer the output buffer
	349	* @param styles array with styles to be appended
	350	*
	351	* @deprecated As of 3.13, replaced by {@link #insertStyles(StringBuilder, String[])}
	352	*/
	353	@Deprecated
198	354	public static void insertStyles(StringBuffer buffer, String[] styles) {
199	355	if (styles == null \|\| styles.length == 0)
200	356	return;

223	379	}
224	380	}
225	381
226		private static void appendStyleSheet(StringBuffer buffer, String styleSheet, RGB fgRGB, RGB bgRGB) {
	382	/**
	383	*
	384	* @param buffer the output buffer
	385	* @param styleSheet the stylesheet
	386	* @param fgRGB Foreground-Color
	387	* @param bgRGB Background-Color
	388	*
	389	*/
	390	private static void appendStyleSheet(StringBuilder buffer, String styleSheet, RGB fgRGB, RGB bgRGB) {
227	391	if (styleSheet == null)
228	392	return;
229	393
230	394	// workaround for https://bugs.eclipse.org/318243
231		StringBuffer fg= new StringBuffer();
	395	StringBuilder fg= new StringBuilder();
232	396	appendColor(fg, fgRGB);
233	397	styleSheet= styleSheet.replaceAll("InfoText", fg.toString()); //$NON-NLS-1$
234		StringBuffer bg= new StringBuffer();
	398	StringBuilder bg= new StringBuilder();
235	399	appendColor(bg, bgRGB);
236	400	styleSheet= styleSheet.replaceAll("InfoBackground", bg.toString()); //$NON-NLS-1$
	401
	402	// replace link colors with colors from preferences
	403	StringBuilder linkColor= new StringBuilder();
	404	appendColor(linkColor, LINK_COLOR_RGB);
	405	styleSheet= styleSheet.replaceAll("hyperlinkColor", linkColor.toString()); //$NON-NLS-1$
	406	StringBuilder activeLinkColor= new StringBuilder();
	407	appendColor(activeLinkColor, ACTIVE_LINK_COLOR_RGB);
	408	styleSheet= styleSheet.replaceAll("activeHyperlinkColor", activeLinkColor.toString()); //$NON-NLS-1$
237	409
238	410	buffer.append("<head><style CHARSET=\"ISO-8859-1\" TYPE=\"text/css\">"); //$NON-NLS-1$
239	411	buffer.append(styleSheet);
240	412	buffer.append("</style></head>"); //$NON-NLS-1$
241	413	}
242	414
243		private static void appendStyleSheetURL(StringBuffer buffer, URL styleSheetURL) {
	415	/**
	416	*
	417	* @param buffer the output buffer
	418	* @param styleSheet the stylesheet
	419	* @param fgRGB Foreground-Color
	420	* @param bgRGB Background-Color
	421	*
	422	* @deprecated migrate to new StringBuilder API
	423	*/
	424	@Deprecated
	425	private static void appendStyleSheet(StringBuffer buffer, String styleSheet, RGB fgRGB, RGB bgRGB) {
	426	if (styleSheet == null)
	427	return;
	428
	429	// workaround for https://bugs.eclipse.org/318243
	430	StringBuilder fg= new StringBuilder();
	431	appendColor(fg, fgRGB);
	432	styleSheet= styleSheet.replaceAll("InfoText", fg.toString()); //$NON-NLS-1$
	433	StringBuilder bg= new StringBuilder();
	434	appendColor(bg, bgRGB);
	435	styleSheet= styleSheet.replaceAll("InfoBackground", bg.toString()); //$NON-NLS-1$
	436
	437	// replace link colors with colors from preferences
	438	StringBuilder linkColor= new StringBuilder();
	439	appendColor(linkColor, LINK_COLOR_RGB);
	440	styleSheet= styleSheet.replaceAll("hyperlinkColor", linkColor.toString()); //$NON-NLS-1$
	441	StringBuilder activeLinkColor= new StringBuilder();
	442	appendColor(activeLinkColor, ACTIVE_LINK_COLOR_RGB);
	443	styleSheet= styleSheet.replaceAll("activeHyperlinkColor", activeLinkColor.toString()); //$NON-NLS-1$
	444
	445	buffer.append("<head><style CHARSET=\"ISO-8859-1\" TYPE=\"text/css\">"); //$NON-NLS-1$
	446	buffer.append(styleSheet);
	447	buffer.append("</style></head>"); //$NON-NLS-1$
	448	}
	449
	450	/**
	451	*
	452	* @param buffer the output buffer
	453	* @param styleSheetURL the URL to the Stylesheet
	454	*
	455	*/
	456	private static void appendStyleSheetURL(StringBuilder buffer, URL styleSheetURL) {
244	457	if (styleSheetURL == null)
245	458	return;
246	459

253	466	buffer.append("</head>"); //$NON-NLS-1$
254	467	}
255	468
	469	/**
	470	*
	471	* @param buffer the output buffer
	472	* @param styleSheetURL the URL to the Stylesheet
	473	*
	474	* @deprecated migrate to new StringBuilder API
	475	*/
	476	@Deprecated
	477	private static void appendStyleSheetURL(StringBuffer buffer, URL styleSheetURL) {
	478	if (styleSheetURL == null)
	479	return;
	480
	481	buffer.append("<head>"); //$NON-NLS-1$
	482
	483	buffer.append("<LINK REL=\"stylesheet\" HREF= \""); //$NON-NLS-1$
	484	buffer.append(styleSheetURL);
	485	buffer.append("\" CHARSET=\"ISO-8859-1\" TYPE=\"text/css\">"); //$NON-NLS-1$
	486
	487	buffer.append("</head>"); //$NON-NLS-1$
	488	}
	489
	490
	491	/**
	492	*
	493	* @param buffer the output buffer
	494	* @param position the offset
	495	*
	496	*/
	497	public static void insertPageProlog(StringBuilder buffer, int position) {
	498	StringBuilder pageProlog= new StringBuilder(60);
	499	pageProlog.append("<html>"); //$NON-NLS-1$
	500	appendColors(pageProlog, FG_COLOR_RGB, BG_COLOR_RGB);
	501	buffer.insert(position, pageProlog.toString());
	502	}
	503
	504	/**
	505	*
	506	* @param buffer the output buffer
	507	* @param position the offset
	508	*
	509	* @deprecated migrate to new StringBuilder API
	510	*/
	511	@Deprecated
256	512	public static void insertPageProlog(StringBuffer buffer, int position) {
257	513	StringBuffer pageProlog= new StringBuffer(60);
258	514	pageProlog.append("<html>"); //$NON-NLS-1$

260	516	buffer.insert(position, pageProlog.toString());
261	517	}
262	518
	519	/**
	520	*
	521	* @param buffer the output buffer
	522	* @param position the offset
	523	* @param styleSheetURL URL to the Stylesheet
	524	*
	525	* @deprecated migrate to new StringBuilder API
	526	*/
	527	@Deprecated
263	528	public static void insertPageProlog(StringBuffer buffer, int position, URL styleSheetURL) {
264	529	StringBuffer pageProlog= new StringBuffer(300);
265	530	pageProlog.append("<html>"); //$NON-NLS-1$

268	533	buffer.insert(position, pageProlog.toString());
269	534	}
270	535
	536	/**
	537	*
	538	* @param buffer the output buffer
	539	* @param position the offset
	540	* @param styleSheetURL URL to the Stylesheet
	541	*
	542	*/
	543	public static void insertPageProlog(StringBuilder buffer, int position, URL styleSheetURL) {
	544	StringBuilder pageProlog= new StringBuilder(300);
	545	pageProlog.append("<html>"); //$NON-NLS-1$
	546	appendStyleSheetURL(pageProlog, styleSheetURL);
	547	appendColors(pageProlog, FG_COLOR_RGB, BG_COLOR_RGB);
	548	buffer.insert(position, pageProlog.toString());
	549	}
	550
	551	/**
	552	*
	553	* @param buffer the output buffer
	554	* @param position the offset
	555	* @param styleSheet Stylesheet
	556	*
	557	*/
	558	public static void insertPageProlog(StringBuilder buffer, int position, String styleSheet) {
	559	insertPageProlog(buffer, position, null, null, styleSheet);
	560	}
	561
	562	/**
	563	*
	564	* @param buffer the output buffer
	565	* @param position the offset
	566	* @param styleSheet Stylesheet
	567	*
	568	* @deprecated migrate to new StringBuilder API
	569	*/
	570	@Deprecated
271	571	public static void insertPageProlog(StringBuffer buffer, int position, String styleSheet) {
272	572	insertPageProlog(buffer, position, null, null, styleSheet);
273	573	}
274	574
	575	/**
	576	*
	577	* @param buffer the output buffer
	578	*
	579	*/
	580	public static void addPageProlog(StringBuilder buffer) {
	581	insertPageProlog(buffer, buffer.length());
	582	}
	583
	584	/**
	585	*
	586	* @param buffer the output buffer
	587	*
	588	* @deprecated migrate to new StringBuilder API
	589	*/
	590	@Deprecated
275	591	public static void addPageProlog(StringBuffer buffer) {
276	592	insertPageProlog(buffer, buffer.length());
277	593	}
278	594
	595	public static void addPageEpilog(StringBuilder buffer) {
	596	buffer.append("</body></html>"); //$NON-NLS-1$
	597	}
	598
	599	/**
	600	*
	601	* @param buffer the output buffer
	602	*
	603	* @deprecated migrate to new StringBuilder API
	604	*/
	605	@Deprecated
279	606	public static void addPageEpilog(StringBuffer buffer) {
280	607	buffer.append("</body></html>"); //$NON-NLS-1$
281	608	}
282	609
	610	/**
	611	*
	612	* @param buffer the output buffer
	613	*
	614	*/
	615	public static void startBulletList(StringBuilder buffer) {
	616	buffer.append("<ul>"); //$NON-NLS-1$
	617	}
	618
	619	/**
	620	*
	621	* @param buffer the output buffer
	622	*
	623	* @deprecated migrate to new StringBuilder API
	624	*/
	625	@Deprecated
283	626	public static void startBulletList(StringBuffer buffer) {
284	627	buffer.append("<ul>"); //$NON-NLS-1$
285	628	}
286	629
	630	/**
	631	* ends the bulletpointlist
	632	*
	633	* @param buffer the output buffer
	634	*
	635	*/
	636	public static void endBulletList(StringBuilder buffer) {
	637	buffer.append("</ul>"); //$NON-NLS-1$
	638	}
	639
	640	/**
	641	* ends the bulletpointlist
	642	*
	643	* @param buffer the output buffer
	644	*
	645	* @deprecated migrate to new StringBuilder API
	646	*/
	647	@Deprecated
287	648	public static void endBulletList(StringBuffer buffer) {
288	649	buffer.append("</ul>"); //$NON-NLS-1$
289	650	}
290	651
	652	/**
	653	* Adds bulletpoint
	654	*
	655	* @param buffer the output buffer
	656	* @param bullet the bulletpoint
	657	*
	658	*/
	659	public static void addBullet(StringBuilder buffer, String bullet) {
	660	if (bullet != null) {
	661	buffer.append("<li>"); //$NON-NLS-1$
	662	buffer.append(bullet);
	663	buffer.append("</li>"); //$NON-NLS-1$
	664	}
	665	}
	666
	667	/**
	668	* Adds bulletpoint
	669	*
	670	* @param buffer the output buffer
	671	* @param bullet the bulletpoint
	672	*
	673	* @deprecated migrate to new StringBuilder API
	674	*/
	675	@Deprecated
291	676	public static void addBullet(StringBuffer buffer, String bullet) {
292	677	if (bullet != null) {
293	678	buffer.append("<li>"); //$NON-NLS-1$

296	681	}
297	682	}
298	683
	684	/**
	685	*
	686	* Adds h5 headline
	687	*
	688	* @param buffer the output buffer
	689	* @param header of h5 headline
	690	*
	691	*/
	692	public static void addSmallHeader(StringBuilder buffer, String header) {
	693	if (header != null) {
	694	buffer.append("<h5>"); //$NON-NLS-1$
	695	buffer.append(header);
	696	buffer.append("</h5>"); //$NON-NLS-1$
	697	}
	698	}
	699
	700	/**
	701	*
	702	* Adds h5 headline
	703	*
	704	* @param buffer the output buffer
	705	* @param header of h5 headline
	706	*
	707	* @deprecated migrate to new StringBuilder API
	708	*/
	709	@Deprecated
299	710	public static void addSmallHeader(StringBuffer buffer, String header) {
300	711	if (header != null) {
301	712	buffer.append("<h5>"); //$NON-NLS-1$

304	715	}
305	716	}
306	717
	718	/**
	719	*
	720	* @param buffer the output buffer
	721	* @param paragraph the content of the paragraph
	722	*
	723	*/
	724	public static void addParagraph(StringBuilder buffer, String paragraph) {
	725	if (paragraph != null) {
	726	buffer.append("<p>"); //$NON-NLS-1$
	727	buffer.append(paragraph);
	728	}
	729	}
	730
	731	/**
	732	*
	733	* @param buffer the output buffer
	734	* @param paragraph the content of the paragraph
	735	*
	736	* @deprecated migrate to new StringBuilder API
	737	*/
	738	@Deprecated
307	739	public static void addParagraph(StringBuffer buffer, String paragraph) {
308	740	if (paragraph != null) {
309	741	buffer.append("<p>"); //$NON-NLS-1$

318	750	* it doesn't starts a new paragraph when rendered with a {@link HTML2TextReader}
319	751	* (e.g. in a {@link DefaultInformationControl} that renders simple HTML).
320	752	*
321		* @param buffer the output buffer
	753	* @param buffer the output StringBuilder
322	754	* @param preFormatted the string that should be rendered with whitespace preserved
323	755	*
324	756	* @see #convertToHTMLContent(String)
325	757	* @see #convertToHTMLContentWithWhitespace(String)
326	758	* @since 3.7
327	759	*/
	760	public static void addPreFormatted(StringBuilder buffer, String preFormatted) {
	761	if (preFormatted != null) {
	762	buffer.append("<pre>"); //$NON-NLS-1$
	763	buffer.append(preFormatted);
	764	buffer.append("</pre>"); //$NON-NLS-1$
	765	}
	766	}
	767
	768	/**
	769	* Appends a string and keeps its whitespace and newlines.
	770	* <p>
	771	* <b>Warning:</b> This starts a new paragraph when rendered in a browser, but
	772	* it doesn't starts a new paragraph when rendered with a {@link HTML2TextReader}
	773	* (e.g. in a {@link DefaultInformationControl} that renders simple HTML).
	774	*
	775	* @param buffer the output buffer
	776	* @param preFormatted the string that should be rendered with whitespace preserved
	777	*
	778	* @deprecated migrate to new StringBuilder API
	779	*
	780	* @see #convertToHTMLContent(String)
	781	* @see #convertToHTMLContentWithWhitespace(String)
	782	* @since 3.7
	783	*/
	784	@Deprecated
328	785	public static void addPreFormatted(StringBuffer buffer, String preFormatted) {
329	786	if (preFormatted != null) {
330	787	buffer.append("<pre>"); //$NON-NLS-1$

333	790	}
334	791	}
335	792
	793	/**
	794	*
	795	* @param buffer the output buffer
	796	* @param paragraphReader The content of the Read will be added to output buffer
	797	*
	798	*/
	799	public static void addParagraph(StringBuilder buffer, Reader paragraphReader) {
	800	if (paragraphReader != null)
	801	addParagraph(buffer, read(paragraphReader));
	802	}
	803
	804	/**
	805	*
	806	* @param buffer the output buffer
	807	* @param paragraphReader The content of the Read will be added to output buffer
	808	*
	809	* @deprecated migrate to new StringBuilder API
	810	*/
	811	@Deprecated
336	812	public static void addParagraph(StringBuffer buffer, Reader paragraphReader) {
337	813	if (paragraphReader != null)
338	814	addParagraph(buffer, read(paragraphReader));

+4

-4

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/html/HTMLTextPresenter.java less more

75	75	}
76	76	}
77	77
78		private void append(StringBuffer buffer, String string, TextPresentation presentation) {
	78	private void append(StringBuilder buffer, String string, TextPresentation presentation) {
79	79
80	80	int length= string.length();
81	81	buffer.append(string);

118	118	GC gc= new GC(drawable);
119	119	try {
120	120
121		StringBuffer buffer= new StringBuffer();
122		int maxNumberOfLines= Math.round(maxHeight / gc.getFontMetrics().getHeight());
	121	StringBuilder buffer= new StringBuilder();
	122	int maxNumberOfLines= (int) Math.round((double) maxHeight / gc.getFontMetrics().getHeight());
123	123
124	124	fCounter= 0;
125	125	LineBreakingReader reader= new LineBreakingReader(createReader(hoverInfo, presentation), hoverInfo.length(), gc, maxWidth);

178	178	}
179	179	}
180	180
181		private String trim(StringBuffer buffer, TextPresentation presentation) {
	181	private String trim(StringBuilder buffer, TextPresentation presentation) {
182	182
183	183	int length= buffer.length();
184	184

+1

-1

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/html/SingleCharReader.java less more

57	57	* @exception IOException in case reading fails
58	58	*/
59	59	public String getString() throws IOException {
60		StringBuffer buf= new StringBuffer();
	60	StringBuilder buf= new StringBuilder();
61	61	int ch;
62	62	while ((ch= read()) != -1) {
63	63	buf.append((char)ch);

+2

-2

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/html/SubstitutionTextReader.java less more

34	34	private boolean fSkipWhiteSpace= true;
35	35
36	36	private boolean fReadFromBuffer;
37		private StringBuffer fBuffer;
	37	private StringBuilder fBuffer;
38	38	private int fIndex;
39	39
40	40
41	41	protected SubstitutionTextReader(Reader reader) {
42	42	fReader= reader;
43		fBuffer= new StringBuffer();
	43	fBuffer= new StringBuilder();
44	44	fIndex= 0;
45	45	fReadFromBuffer= false;
46	46	fCharAfterWhiteSpace= -1;

+18

-7

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/link/contentassist/CompletionProposalPopup2.java less more

30	30	import org.eclipse.swt.layout.GridData;
31	31	import org.eclipse.swt.layout.GridLayout;
32	32	import org.eclipse.swt.widgets.Control;
	33	import org.eclipse.swt.widgets.Display;
33	34	import org.eclipse.swt.widgets.Shell;
34	35	import org.eclipse.swt.widgets.Table;
35	36	import org.eclipse.swt.widgets.TableItem;
36	37
37	38	import org.eclipse.jface.internal.text.TableOwnerDrawSupport;
	39	import org.eclipse.jface.preference.JFacePreferences;
	40	import org.eclipse.jface.resource.ColorRegistry;
	41	import org.eclipse.jface.resource.JFaceColors;
38	42	import org.eclipse.jface.resource.JFaceResources;
39	43	import org.eclipse.jface.viewers.StyledString;
40	44

310	314	});
311	315	}
312	316
313		fProposalShell.setBackground(control.getDisplay().getSystemColor(SWT.COLOR_BLACK));
314
315		Color c= control.getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND);
316		fProposalTable.setBackground(c);
317
318		c= control.getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND);
319		fProposalTable.setForeground(c);
	317	ColorRegistry colorRegistry= JFaceResources.getColorRegistry();
	318	Color background= colorRegistry.get(JFacePreferences.CONTENT_ASSIST_BACKGROUND_COLOR);
	319	if (background == null) {
	320	background= JFaceColors.getInformationViewerBackgroundColor(Display.getDefault());
	321	}
	322
	323	Color foreground= colorRegistry.get(JFacePreferences.CONTENT_ASSIST_FOREGROUND_COLOR);
	324	if (foreground == null) {
	325	foreground= JFaceColors.getInformationViewerBackgroundColor(Display.getDefault());
	326	}
	327
	328	fProposalShell.setBackground(background);
	329	fProposalTable.setBackground(background);
	330	fProposalTable.setForeground(foreground);
320	331
321	332	fProposalTable.addSelectionListener(new SelectionListener() {
322	333

+6

-6

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/revisions/RevisionPainter.java less more

160	160	return;
161	161	List<Long> revisions= new ArrayList<>();
162	162	for (Revision revision : info.getRevisions()) {
163		revisions.add(new Long(computeAge(revision)));
	163	revisions.add(Long.valueOf(computeAge(revision)));
164	164	}
165	165	Collections.sort(revisions);
166	166	fRevisions= revisions;

204	204
205	205	private int computeAgeIndex(Revision revision) {
206	206	long age= computeAge(revision);
207		int index= fRevisions.indexOf(new Long(age));
	207	int index= fRevisions.indexOf(Long.valueOf(age));
208	208	return index;
209	209	}
210	210

375	375	// there is already a header
376	376	return html;
377	377
378		StringBuffer info= new StringBuffer(512 + html.length());
	378	StringBuilder info= new StringBuilder(512 + html.length());
379	379	HTMLPrinter.insertPageProlog(info, 0, fgStyleSheet);
380	380	info.append(html);
381	381	HTMLPrinter.addPageEpilog(info);

416	416	"dd { margin-top: 0; margin-bottom: 0 }\n" + //$NON-NLS-1$
417	417	"\n" + //$NON-NLS-1$
418	418	"/* Styles and colors */\n" + //$NON-NLS-1$
419		"a:link { color: #0000FF }\n" + //$NON-NLS-1$
420		"a:hover { color: #000080 }\n" + //$NON-NLS-1$
	419	"a:link { color: hyperlinkColor }\n" + //$NON-NLS-1$
	420	"a:hover { color: activeHyperlinkColor; }\n" + //$NON-NLS-1$
421	421	"a:visited { text-decoration: underline }\n" + //$NON-NLS-1$
422	422	"h4 { font-style: italic }\n" + //$NON-NLS-1$
423	423	"strong { font-weight: bold }\n" + //$NON-NLS-1$

663	663
664	664	/**
665	665	* Sets the zoom level for the current painting operation. Workaround for bug 516293.
666		*
	666	*
667	667	* @param zoom the zoom to set
668	668	* @since 3.12
669	669	*/

+2

-3

org.eclipse.jface.text/src/org/eclipse/jface/internal/text/source/DiffPainter.java less more

140	140
141	141	/**
142	142	* Sets the zoom level for the current painting operation. Workaround for bug 516293.
143		*
	143	*
144	144	* @param zoom the zoom to set
145	145	* @since 3.12
146	146	*/

368	368	if (fLineDiffer != null)
369	369	((IAnnotationModel) fLineDiffer).removeAnnotationModelListener(fAnnotationListener);
370	370	fLineDiffer= (ILineDiffer) differ;
371		if (fLineDiffer != null)
372		((IAnnotationModel) fLineDiffer).addAnnotationModelListener(fAnnotationListener);
	371	((IAnnotationModel) fLineDiffer).addAnnotationModelListener(fAnnotationListener);
373	372	}
374	373	}
375	374	}

+4

-3

org.eclipse.jface.text/src/org/eclipse/jface/text/AbstractInformationControl.java less more

433	433	* The shell of the popup window.
434	434	*
435	435	* @return the shell used for the popup window
436		*/
437		protected final Shell getShell() {
	436	* @since 3.13
	437	*/
	438	public final Shell getShell() {
438	439	return fShell;
439	440	}
440	441

645	646	setStatusLabelColors(fStatusLabel.getForeground(), background);
646	647	}
647	648	}
648
	649
649	650	private void setStatusLabelColors(Color foreground, Color background) {
650	651	if (foreground == null \|\| background == null) return;
651	652	if (fStatusLabelForeground != null) {

+1

-1

org.eclipse.jface.text/src/org/eclipse/jface/text/DefaultIndentLineAutoEditStrategy.java less more

68	68	// find white spaces
69	69	int end= findEndOfWhiteSpace(d, start, c.offset);
70	70
71		StringBuffer buf= new StringBuffer(c.text);
	71	StringBuilder buf= new StringBuilder(c.text);
72	72	if (end > start) {
73	73	// append to input
74	74	buf.append(d.get(start, end - start));

+5

-5

org.eclipse.jface.text/src/org/eclipse/jface/text/DefaultUndoManager.java less more

372	372	@Override
373	373	public String toString() {
374	374	String delimiter= ", "; //$NON-NLS-1$
375		StringBuffer text= new StringBuffer(super.toString());
	375	StringBuilder text= new StringBuilder(super.toString());
376	376	text.append("\n"); //$NON-NLS-1$
377	377	text.append(this.getClass().getName());
378	378	text.append(" undo modification stamp: "); //$NON-NLS-1$

767	767	}
768	768
769	769	/** Text buffer to collect text which is inserted into the viewer */
770		private StringBuffer fTextBuffer;
	770	private StringBuilder fTextBuffer;
771	771	/** Text buffer to collect viewer content which has been replaced */
772		private StringBuffer fPreservedTextBuffer;
	772	private StringBuilder fPreservedTextBuffer;
773	773	/** The document modification stamp for undo. */
774	774	protected long fPreservedUndoModificationStamp= IDocumentExtension4.UNKNOWN_MODIFICATION_STAMP;
775	775	/** The document modification stamp for redo. */

1198	1198	public void connect(ITextViewer textViewer) {
1199	1199	if (!isConnected() && textViewer != null) {
1200	1200	fTextViewer= textViewer;
1201		fTextBuffer= new StringBuffer();
1202		fPreservedTextBuffer= new StringBuffer();
	1201	fTextBuffer= new StringBuilder();
	1202	fPreservedTextBuffer= new StringBuilder();
1203	1203	if (fUndoContext == null)
1204	1204	fUndoContext= new ObjectUndoContext(this);
1205	1205

+9

-6

org.eclipse.jface.text/src/org/eclipse/jface/text/JFaceTextUtil.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2006, 2016 IBM Corporation and others.
	1	* Copyright (c) 2006, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

419	419	* @since 3.5
420	420	*/
421	421	public static int getOffsetForCursorLocation(ITextViewer viewer) {
422
423	422	try {
424	423	StyledText text= viewer.getTextWidget();
425		if (text == null \|\| text.isDisposed())
	424	if (text == null \|\| text.isDisposed()) {
426	425	return -1;
	426	}
427	427
428	428	Display display= text.getDisplay();
429	429	Point absolutePosition= display.getCursorLocation();
430	430	Point relativePosition= text.toControl(absolutePosition);
431	431
432		int widgetOffset= text.getOffsetAtLocation(relativePosition);
	432	int widgetOffset= text.getOffsetAtPoint(relativePosition);
	433	if (widgetOffset == -1) {
	434	return -1;
	435	}
433	436	Point p= text.getLocationAtOffset(widgetOffset);
434		if (p.x > relativePosition.x)
	437	if (p.x > relativePosition.x) {
435	438	widgetOffset--;
	439	}
436	440
437	441	if (viewer instanceof ITextViewerExtension5) {
438	442	ITextViewerExtension5 extension= (ITextViewerExtension5)viewer;

440	444	}
441	445
442	446	return widgetOffset + viewer.getVisibleRegion().getOffset();
443
444	447	} catch (IllegalArgumentException e) {
445	448	return -1;
446	449	}

+6

-6

org.eclipse.jface.text/src/org/eclipse/jface/text/MarginPainter.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2008 IBM Corporation and others.
	1	* Copyright (c) 2000, 2017 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

45	45	/** The line width of the line to be painted, default value <code>1</code> */
46	46	private int fLineWidth= 0; // NOTE: 0 means width is 1 but with optimized performance
47	47	/** The cached x-offset of the <code>fMarginWidth</code> for the current font */
48		private int fCachedWidgetX= -1;
	48	private int fCachedWidgetX= -1;
49	49	private Font fFontForCachedWidgetX;
50	50	/** The active state of this painter */
51	51	private boolean fIsActive= false;

99	99	}
100	100
101	101	/**
102		* Initializes this painter, by flushing and recomputing all caches and causing
103		* the widget to be redrawn. Must be called explicitly when font of text widget changes.
	102	* Initializes this painter, by flushing and recomputing all caches and causing the widget to be
	103	* redrawn.
104	104	*/
105	105	public void initialize() {
106	106	computeWidgetX();

114	114	private void computeWidgetX() {
115	115	GC gc= new GC(fTextWidget);
116	116	fFontForCachedWidgetX= fTextWidget.getFont();
117		int pixels= gc.getFontMetrics().getAverageCharWidth();
	117	double pixels= gc.getFontMetrics().getAverageCharacterWidth();
118	118	gc.dispose();
119	119
120		fCachedWidgetX= pixels * fMarginWidth;
	120	fCachedWidgetX= (int) (pixels * fMarginWidth + 0.5);
121	121	}
122	122
123	123	@Override

+3

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/PaintManager.java less more

146	146	*/
147	147	@Override
148	148	public void managePosition(Position position) {
	149	if (fDocument == null) {
	150	return;
	151	}
149	152	try {
150	153	fDocument.addPosition(fCategory, position);
151	154	} catch (BadPositionCategoryException x) {

+2

-4

org.eclipse.jface.text/src/org/eclipse/jface/text/PropagatingFontFieldEditor.java less more

13	13
14	14	import org.eclipse.swt.graphics.FontData;
15	15	import org.eclipse.swt.widgets.Composite;
16		import org.eclipse.swt.widgets.Control;
17	16	import org.eclipse.swt.widgets.Label;
18	17
19	18	import org.eclipse.jface.preference.FontFieldEditor;

78	77	*/
79	78	private void checkForDefault() {
80	79	if (presentsDefaultValue()) {
81		Control c= getValueControl(fParent);
82		if (c instanceof Label)
83		((Label) c).setText(fDefaultFontLabel);
	80	Label label= getValueControl(fParent);
	81	label.setText(fDefaultFontLabel);
84	82	}
85	83	}
86	84

+2

-2

org.eclipse.jface.text/src/org/eclipse/jface/text/TabsToSpacesConverter.java less more

33	33	fLineTracker= lineTracker;
34	34	}
35	35
36		private int insertTabString(StringBuffer buffer, int offsetInLine) {
	36	private int insertTabString(StringBuilder buffer, int offsetInLine) {
37	37
38	38	if (fTabRatio == 0)
39	39	return 0;

54	54	int index= text.indexOf('\t');
55	55	if (index > -1) {
56	56
57		StringBuffer buffer= new StringBuffer();
	57	StringBuilder buffer= new StringBuilder();
58	58
59	59	fLineTracker.set(command.text);
60	60	int lines= fLineTracker.getNumberOfLines();

+2

-2

org.eclipse.jface.text/src/org/eclipse/jface/text/TextViewer.java less more

3738	3738	} else {
3739	3739	int lines= processor.getCoveredLines(selection);
3740	3740	String delim= fDocument.getLegalLineDelimiters()[0];
3741		StringBuffer text= new StringBuffer(lines * length + (lines - 1) * delim.length());
	3741	StringBuilder text= new StringBuilder(lines * length + (lines - 1) * delim.length());
3742	3742	text.append(e.text);
3743	3743	for (int i= 0; i < lines - 1; i++) {
3744	3744	text.append(delim);

3961	3961	int length= contents.length();
3962	3962	int lines= processor.getCoveredLines(selection);
3963	3963	String delim= fDocument.getLegalLineDelimiters()[0];
3964		StringBuffer text= new StringBuffer(lines * length + (lines - 1) * delim.length());
	3964	StringBuilder text= new StringBuilder(lines * length + (lines - 1) * delim.length());
3965	3965	text.append(contents);
3966	3966	for (int i= 0; i < lines - 1; i++) {
3967	3967	text.append(delim);

+15

-13

org.eclipse.jface.text/src/org/eclipse/jface/text/TextViewerHoverManager.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2012 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

221	221	*/
222	222	@Override
223	223	protected void presentInformation() {
224		if (fTextViewer == null)
225		return;
	224	if (fTextViewer == null) {
	225	return;
	226	}
226	227
227	228	StyledText textWidget= fTextViewer.getTextWidget();
228	229	if (textWidget != null && !textWidget.isDisposed()) {
229	230	Display display= textWidget.getDisplay();
230		if (display == null)
	231	if (display == null) {
231	232	return;
232
233		display.asyncExec(new Runnable() {
234		@Override
235		public void run() {
	233	}
	234
	235	display.asyncExec(() -> {
	236	if (!textWidget.isDisposed()) {
236	237	doPresentInformation();
237	238	}
238	239	});

257	258	* @return the document offset corresponding to the given point
258	259	*/
259	260	private int computeOffsetAtLocation(int x, int y) {
260
261	261	try {
262
263	262	StyledText styledText= fTextViewer.getTextWidget();
264		int widgetOffset= styledText.getOffsetAtLocation(new Point(x, y));
	263	int widgetOffset= styledText.getOffsetAtPoint(new Point(x, y));
	264	if (widgetOffset == -1) {
	265	return -1;
	266	}
265	267	Point p= styledText.getLocationAtOffset(widgetOffset);
266		if (p.x > x)
	268	if (p.x > x) {
267	269	widgetOffset--;
	270	}
268	271
269	272	if (fTextViewer instanceof ITextViewerExtension5) {
270	273	ITextViewerExtension5 extension= (ITextViewerExtension5) fTextViewer;

272	275	}
273	276
274	277	return widgetOffset + fTextViewer._getVisibleRegionOffset();
275
276	278	} catch (IllegalArgumentException e) {
277	279	return -1;
278	280	}

+9

-14

org.eclipse.jface.text/src/org/eclipse/jface/text/WhitespaceCharacterPainter.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2006, 2017 Wind River Systems, Inc., IBM Corporation and others.
	1	* Copyright (c) 2006, 2018 Wind River Systems, Inc., IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

249	249	// Y-coordinate of line
250	250	int y= fTextWidget.getLinePixel(line);
251	251	// compute first visible char offset
252		int startOffset;
253		try {
254		startOffset= fTextWidget.getOffsetAtLocation(new Point(x, y)) - 1;
255		if (startOffset - 2 <= lineOffset) {
256		startOffset= lineOffset;
257		}
258		} catch (IllegalArgumentException iae) {
	252	int startOffset = fTextWidget.getOffsetAtPoint(new Point(x, y)) - 1;
	253	if (startOffset == -1) {
	254	startOffset= lineOffset;
	255	} else if (startOffset - 2 <= lineOffset) {
259	256	startOffset= lineOffset;
260	257	}
261	258	// compute last visible char offset

264	261	// line end is visible
265	262	endOffset= lineEndOffset;
266	263	} else {
267		try {
268		endOffset= fTextWidget.getOffsetAtLocation(new Point(x + w - 1, y)) + 1;
269		if (endOffset + 2 >= lineEndOffset) {
270		endOffset= lineEndOffset;
271		}
272		} catch (IllegalArgumentException iae) {
	264	endOffset= fTextWidget.getOffsetAtPoint(new Point(x + w - 1, y)) + 1;
	265	if (endOffset == -1) {
	266	endOffset= lineEndOffset;
	267	} else if (endOffset + 2 >= lineEndOffset) {
273	268	endOffset= lineEndOffset;
274	269	}
275	270	}

+151

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/AbstractCodeMining.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide CodeMining support with CodeMiningManager - Bug 527720
	9	*/
	10	package org.eclipse.jface.text.codemining;
	11
	12	import java.util.concurrent.CompletableFuture;
	13	import java.util.function.Consumer;
	14
	15	import org.eclipse.swt.custom.StyledText;
	16	import org.eclipse.swt.events.MouseEvent;
	17	import org.eclipse.swt.graphics.Color;
	18	import org.eclipse.swt.graphics.GC;
	19	import org.eclipse.swt.graphics.Point;
	20
	21	import org.eclipse.core.runtime.IProgressMonitor;
	22
	23	import org.eclipse.jface.text.ITextViewer;
	24	import org.eclipse.jface.text.Position;
	25
	26	/**
	27	* Abstract class for {@link ICodeMining}.
	28	*
	29	* @since 3.13
	30	*/
	31	public abstract class AbstractCodeMining implements ICodeMining {
	32
	33	/**
	34	* The position where codemining must be drawn
	35	*/
	36	private final Position position;
	37
	38	/**
	39	* The owner codemining provider which creates this mining.
	40	*/
	41	private final ICodeMiningProvider provider;
	42
	43	/**
	44	* The future used to resolve mining.
	45	*/
	46	private CompletableFuture<Void> resolveFuture;
	47
	48	/**
	49	* The label of the resolved codemining.
	50	*/
	51	private String label;
	52
	53	/**
	54	* The action to execute when mining is clicked and null otherwise.
	55	*/
	56	private final Consumer<MouseEvent> action;
	57
	58	/**
	59	* CodeMining constructor to locate the code mining in a given position.
	60	*
	61	* @param position the position where the mining must be drawn.
	62	* @param provider the owner codemining provider which creates this mining.
	63	* @param action the action to execute when mining is clicked and null otherwise.
	64	*/
	65	protected AbstractCodeMining(Position position, ICodeMiningProvider provider, Consumer<MouseEvent> action) {
	66	this.position= position;
	67	this.provider= provider;
	68	this.action= action;
	69	}
	70
	71	@Override
	72	public Position getPosition() {
	73	return position;
	74	}
	75
	76	@Override
	77	public ICodeMiningProvider getProvider() {
	78	return provider;
	79	}
	80
	81	@Override
	82	public String getLabel() {
	83	return label;
	84	}
	85
	86	/**
	87	* Set the label mining.
	88	*
	89	* @param label the label mining.
	90	*/
	91	public void setLabel(String label) {
	92	this.label= label;
	93	}
	94
	95	@Override
	96	public final CompletableFuture<Void> resolve(ITextViewer viewer, IProgressMonitor monitor) {
	97	if (resolveFuture == null) {
	98	resolveFuture= doResolve(viewer, monitor);
	99	}
	100	return resolveFuture;
	101	}
	102
	103	/**
	104	* Returns the future which resolved the content of mining and null otherwise. By default, the
	105	* resolve do nothing.
	106	*
	107	* @param viewer the viewer
	108	* @param monitor the monitor
	109	* @return the future which resolved the content of mining and null otherwise.
	110	*/
	111	protected CompletableFuture<Void> doResolve(ITextViewer viewer, IProgressMonitor monitor) {
	112	return CompletableFuture.completedFuture(null);
	113	}
	114
	115	@Override
	116	public boolean isResolved() {
	117	return (resolveFuture != null && resolveFuture.isDone());
	118	}
	119
	120	@Override
	121	public void dispose() {
	122	if (resolveFuture != null) {
	123	resolveFuture.cancel(true);
	124	resolveFuture= null;
	125	}
	126	}
	127
	128	/**
	129	* Draw the {@link #getLabel()} of mining with gray color. User can override this method to draw
	130	* anything.
	131	*
	132	* @param gc the graphics context
	133	* @param textWidget the text widget to draw on
	134	* @param color the color of the line
	135	* @param x the x position of the annotation
	136	* @param y the y position of the annotation
	137	* @return the size of the draw of mining.
	138	*/
	139	@Override
	140	public Point draw(GC gc, StyledText textWidget, Color color, int x, int y) {
	141	String title= getLabel() != null ? getLabel() : "no command"; //$NON-NLS-1$
	142	gc.drawString(title, x, y, true);
	143	return gc.stringExtent(title);
	144	}
	145
	146	@Override
	147	public Consumer<MouseEvent> getAction() {
	148	return action;
	149	}
	150	}

+65

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/AbstractCodeMiningProvider.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide CodeMining support with CodeMiningManager - Bug 527720
	9	*/
	10	package org.eclipse.jface.text.codemining;
	11
	12	import org.eclipse.core.runtime.Assert;
	13	import org.eclipse.core.runtime.IAdaptable;
	14
	15	/**
	16	* A codemining provider that can provide adapters through a context that can be set by the creator
	17	* of this codemining provider.
	18	* <p>
	19	* Clients may subclass.
	20	* </p>
	21	*
	22	* @since 3.13
	23	*/
	24	public abstract class AbstractCodeMiningProvider implements ICodeMiningProvider {
	25
	26	/**
	27	* The context of this codemining provider.
	28	*/
	29	private IAdaptable context;
	30
	31	/**
	32	* Sets this codemining provider's context which is responsible to provide the adapters.
	33	*
	34	* @param context the context for this codemining provider
	35	* @throws IllegalArgumentException if the context is <code>null</code>
	36	* @throws IllegalStateException if this method is called more than once
	37	*/
	38	public final void setContext(IAdaptable context) throws IllegalStateException, IllegalArgumentException {
	39	Assert.isLegal(context != null);
	40	if (this.context != null)
	41	throw new IllegalStateException();
	42	this.context= context;
	43	}
	44
	45	@Override
	46	public void dispose() {
	47	context= null;
	48	}
	49
	50	/**
	51	* Returns an object which is an instance of the given class and provides additional context for
	52	* this codemining provider.
	53	*
	54	* @param adapterClass the adapter class to look up
	55	* @return an instance that can be cast to the given class, or <code>null</code> if this object
	56	* does not have an adapter for the given class
	57	*/
	58	protected final <T> T getAdapter(Class<T> adapterClass) {
	59	Assert.isLegal(adapterClass != null);
	60	if (context != null)
	61	return context.getAdapter(adapterClass);
	62	return null;
	63	}
	64	}

+44

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/CodeMiningReconciler.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide extension point for CodeMining - Bug 528419
	9	*/
	10	package org.eclipse.jface.text.codemining;
	11
	12	import org.eclipse.jface.text.IDocument;
	13	import org.eclipse.jface.text.ITextViewer;
	14	import org.eclipse.jface.text.reconciler.Reconciler;
	15
	16	/**
	17	* A reconciler which update code minings.
	18	*
	19	* @since 3.13
	20	*/
	21	public class CodeMiningReconciler extends Reconciler {
	22
	23	private CodeMiningStrategy fStrategy;
	24
	25	public CodeMiningReconciler() {
	26	super.setIsIncrementalReconciler(false);
	27	fStrategy= new CodeMiningStrategy();
	28	this.setReconcilingStrategy(fStrategy, IDocument.DEFAULT_CONTENT_TYPE);
	29	}
	30
	31	@Override
	32	public void install(ITextViewer textViewer) {
	33	super.install(textViewer);
	34	fStrategy.install(textViewer);
	35	}
	36
	37	@Override
	38	public void uninstall() {
	39	super.uninstall();
	40	fStrategy.uninstall();
	41	}
	42
	43	}

+72

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/CodeMiningStrategy.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide extension point for CodeMining - Bug 528419
	9	*/
	10	package org.eclipse.jface.text.codemining;
	11
	12	import org.eclipse.core.runtime.IProgressMonitor;
	13
	14	import org.eclipse.jface.text.IDocument;
	15	import org.eclipse.jface.text.IRegion;
	16	import org.eclipse.jface.text.ITextViewer;
	17	import org.eclipse.jface.text.reconciler.DirtyRegion;
	18	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	19	import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
	20	import org.eclipse.jface.text.source.ISourceViewerExtension5;
	21
	22	/**
	23	* A reconciling strategy which updates code minings.
	24	*
	25	* @since 3.13
	26	*/
	27	class CodeMiningStrategy implements IReconcilingStrategy, IReconcilingStrategyExtension {
	28
	29	private ISourceViewerExtension5 fViewer;
	30
	31	public void install(ITextViewer viewer) {
	32	if (viewer instanceof ISourceViewerExtension5) {
	33	fViewer= (ISourceViewerExtension5) viewer;
	34	}
	35	}
	36
	37	@Override
	38	public void initialReconcile() {
	39	// Do nothing
	40	// Initial reconcilation will happen when the SourceViewer
	41	// has initialized the code mining provider
	42	// see SourceViewer#ensureCodeMiningManagerInstalled
	43	}
	44
	45	@Override
	46	public void reconcile(IRegion partition) {
	47	if (fViewer != null) {
	48	fViewer.updateCodeMinings();
	49	}
	50	}
	51
	52	public void uninstall() {
	53	fViewer= null;
	54	}
	55
	56	@Override
	57	public void setProgressMonitor(IProgressMonitor monitor) {
	58	// Do nothing
	59	}
	60
	61	@Override
	62	public void setDocument(IDocument document) {
	63	// Do nothing
	64	}
	65
	66	@Override
	67	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	68	// Do nothing
	69	}
	70
	71	}

+119

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/ICodeMining.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide CodeMining support with CodeMiningManager - Bug 527720
	9	*/
	10	package org.eclipse.jface.text.codemining;
	11
	12	import java.util.concurrent.CompletableFuture;
	13	import java.util.function.Consumer;
	14
	15	import org.eclipse.swt.custom.StyledText;
	16	import org.eclipse.swt.events.MouseEvent;
	17	import org.eclipse.swt.graphics.Color;
	18	import org.eclipse.swt.graphics.GC;
	19	import org.eclipse.swt.graphics.Point;
	20
	21	import org.eclipse.core.runtime.IProgressMonitor;
	22
	23	import org.eclipse.jface.text.ITextViewer;
	24	import org.eclipse.jface.text.Position;
	25
	26	/**
	27	* A code mining represents a content (ex: label, icons) that should be shown along with source
	28	* text, like the number of references, a way to run tests (with run/debug icons), etc.
	29	*
	30	* A code mining is unresolved when no content (ex: label, icons) is associated to it. For
	31	* performance reasons the creation of a code mining and resolving should be done to two stages.
	32	*
	33	* @since 3.13
	34	*/
	35	public interface ICodeMining {
	36
	37	/**
	38	* Returns the line position where code mining must be displayed in the line spacing area.
	39	*
	40	* @return the line position where code mining must be displayed in the line spacing area.
	41	*/
	42	Position getPosition();
	43
	44	/**
	45	* Returns the owner provider which has created this mining.
	46	*
	47	* @return the owner provider which has created this mining.
	48	*/
	49	ICodeMiningProvider getProvider();
	50
	51	/**
	52	* Returns the label may be set early in the class lifecycle, or upon completion of the future
	53	* provided by {@link #resolve(ITextViewer, IProgressMonitor)} operation.
	54	*
	55	* <p>
	56	* The returned label can have several values:
	57	* <ul>
	58	* <li><code>null</code> when mining is not resolved</li>
	59	* <li><code>null</code> when mining is resolved means that mining was resolved with an error and it will not
	60	* be displayed.</li>
	61	* <li>empty when mining is resolved means that mining will not be displayed</li>
	62	* <li>non empty when mining must be displayed</li>
	63	* </ul>
	64	* </p>
	65	*
	66	* @return the label may be set early in the class lifecycle, or upon completion of the future
	67	* provided by {@link #resolve(ITextViewer, IProgressMonitor)} operation.
	68	*/
	69	String getLabel();
	70
	71	/**
	72	* Returns the future to resolve the content of mining, or
	73	* {@link CompletableFuture#completedFuture(Object)} if no such resolution is necessary (in
	74	* which case {#isResolved()} is expected to return <code>true</code>).
	75	*
	76	* @param viewer the viewer.
	77	* @param monitor the monitor.
	78	* @return the future to resolve the content of mining, or
	79	* {@link CompletableFuture#completedFuture(Object)} if no such resolution is necessary
	80	* (in which case {#isResolved()} is expected to return <code>true</code>).
	81	*/
	82	CompletableFuture<Void> resolve(ITextViewer viewer, IProgressMonitor monitor);
	83
	84	/**
	85	* Returns whether the content mining is resolved. If it is not resolved,
	86	* {{@link #resolve(ITextViewer, IProgressMonitor)}} will be invoked later, triggering the
	87	* future to resolve content.
	88	*
	89	* @return whether the content mining is resolved. If it is not resolved,
	90	* {{@link #resolve(ITextViewer, IProgressMonitor)}} will be invoked later, triggering
	91	* the future to resolve content.
	92	*/
	93	boolean isResolved();
	94
	95	/**
	96	* Draw the code mining.
	97	*
	98	* @param gc the graphics context
	99	* @param textWidget the text widget to draw on
	100	* @param color the color of the line
	101	* @param x the x position of the annotation
	102	* @param y the y position of the annotation
	103	* @return the size of the draw of mining.
	104	*/
	105	Point draw(GC gc, StyledText textWidget, Color color, int x, int y);
	106
	107	/**
	108	* Returns the action to execute when mining is clicked and null otherwise.
	109	*
	110	* @return the action to execute when mining is clicked and null otherwise.
	111	*/
	112	Consumer<MouseEvent> getAction();
	113
	114	/**
	115	* Dispose the mining. Typically shuts down or cancels all related asynchronous operations.
	116	*/
	117	void dispose();
	118	}

+45

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/ICodeMiningProvider.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide CodeMining support with CodeMiningManager - Bug 527720
	9	*/
	10	package org.eclipse.jface.text.codemining;
	11
	12	import java.util.List;
	13	import java.util.concurrent.CompletableFuture;
	14
	15	import org.eclipse.core.runtime.IProgressMonitor;
	16
	17	import org.eclipse.jface.text.ITextViewer;
	18
	19	/**
	20	* A code mining provider adds minings {@link ICodeMining} to source text. The mining will be shown
	21	* as dedicated horizontal lines in between the source text.
	22	*
	23	* @since 3.13
	24	*/
	25	public interface ICodeMiningProvider {
	26
	27	/**
	28	* Compute a list of code minings {@link ICodeMining}. This call should return as fast as
	29	* possible and if computing the content of {@link ICodeMining} is expensive implementors should
	30	* only return code mining objects with the position and implement resolve
	31	* {@link ICodeMining#resolve(ITextViewer, IProgressMonitor)}.
	32	*
	33	* @param viewer the viewer in which the command was invoked.
	34	* @param monitor A progress monitor.
	35	* @return An array of future of code minings that resolves to such. The lack of a result can be
	36	* signaled by returning null, or an empty array.
	37	*/
	38	CompletableFuture<List<? extends ICodeMining>> provideCodeMinings(ITextViewer viewer, IProgressMonitor monitor);
	39
	40	/**
	41	* Dispose code mining provider.
	42	*/
	43	void dispose();
	44	}

+48

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/LineContentCodeMining.java less more

	0	/**
	1	* Copyright (c) 2018, Angelo ZERR and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] CodeMining should support line header/content annotation type both - Bug 529115
	9	*/
	10	package org.eclipse.jface.text.codemining;
	11
	12	import java.util.function.Consumer;
	13
	14	import org.eclipse.swt.events.MouseEvent;
	15
	16	import org.eclipse.jface.text.Position;
	17
	18	/**
	19	* Abstract class for line content code mining.
	20	*
	21	* @since 3.13
	22	*
	23	*/
	24	public abstract class LineContentCodeMining extends AbstractCodeMining {
	25
	26	/**
	27	* CodeMining constructor to locate the code mining in a given position.
	28	*
	29	* @param position the position where the mining must be drawn.
	30	* @param provider the owner codemining provider which creates this mining.
	31	*/
	32	public LineContentCodeMining(Position position, ICodeMiningProvider provider) {
	33	this(position, provider, null);
	34	}
	35
	36	/**
	37	* CodeMining constructor to locate the code mining in a given position.
	38	*
	39	* @param position the position where the mining must be drawn.
	40	* @param provider the owner codemining provider which creates this mining.
	41	* @param action the action to execute when mining is clicked and null otherwise.
	42	*/
	43	public LineContentCodeMining(Position position, ICodeMiningProvider provider, Consumer<MouseEvent> action) {
	44	super(position, provider, action);
	45	}
	46
	47	}

+57

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/LineHeaderCodeMining.java less more

	0	/**
	1	* Copyright (c) 2018, Angelo ZERR and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] CodeMining should support line header/content annotation type both - Bug 529115
	9	*/
	10	package org.eclipse.jface.text.codemining;
	11
	12	import java.util.function.Consumer;
	13
	14	import org.eclipse.swt.events.MouseEvent;
	15
	16	import org.eclipse.jface.text.BadLocationException;
	17	import org.eclipse.jface.text.IDocument;
	18	import org.eclipse.jface.text.source.inlined.Positions;
	19
	20	/**
	21	* Abstract class for line header code mining.
	22	*
	23	* @since 3.13
	24	*
	25	*/
	26	public abstract class LineHeaderCodeMining extends AbstractCodeMining {
	27
	28	/**
	29	* CodeMining constructor to locate the code mining before the given line number.
	30	*
	31	* @param beforeLineNumber the line number where codemining must be drawn. Use 0 if you wish to
	32	* locate the code mining before the first line number (1).
	33	* @param document the document.
	34	* @param provider the owner codemining provider which creates this mining.
	35	* @throws BadLocationException when line number doesn't exists
	36	*/
	37	public LineHeaderCodeMining(int beforeLineNumber, IDocument document, ICodeMiningProvider provider) throws BadLocationException {
	38	this(beforeLineNumber, document, provider, null);
	39	}
	40
	41	/**
	42	* CodeMining constructor to locate the code mining before the given line number.
	43	*
	44	* @param beforeLineNumber the line number where codemining must be drawn. Use 0 if you wish to
	45	* locate the code mining before the first line number (1).
	46	* @param document the document.
	47	* @param provider the owner codemining provider which creates this mining.
	48	* @param action the action to execute when mining is clicked and null otherwise.
	49	* @throws BadLocationException when line number doesn't exists
	50	*/
	51	public LineHeaderCodeMining(int beforeLineNumber, IDocument document, ICodeMiningProvider provider, Consumer<MouseEvent> action)
	52	throws BadLocationException {
	53	super(Positions.of(beforeLineNumber, document, true), provider, action);
	54	}
	55
	56	}

+167

-63

org.eclipse.jface.text/src/org/eclipse/jface/text/contentassist/AsyncCompletionProposalPopup.java less more

20	20	import java.util.concurrent.Future;
21	21	import java.util.concurrent.TimeUnit;
22	22	import java.util.concurrent.TimeoutException;
	23	import java.util.function.Consumer;
23	24
24	25	import org.eclipse.osgi.util.NLS;
25	26

31	32	import org.eclipse.jface.contentassist.IContentAssistSubjectControl;
32	33
33	34	import org.eclipse.jface.text.BadLocationException;
	35	import org.eclipse.jface.text.DocumentEvent;
34	36	import org.eclipse.jface.text.IDocument;
35	37	import org.eclipse.jface.text.ITextViewer;
36	38	import org.eclipse.jface.text.TextUtilities;

39	41	* This class is used to present proposals asynchronously to the user. If additional information
40	42	* exists for a proposal, then selecting that proposal will result in the information being
41	43	* displayed in a secondary window.
42		*
	44	*
43	45	* @since 3.12
44	46	*/
45	47	class AsyncCompletionProposalPopup extends CompletionProposalPopup {

52	54	private final int fOffset;
53	55	private final int fSize;
54	56	private int fRemaining;
55
	57
56	58	public ComputingProposal(int offset, int size) {
57	59	fSize= size;
58	60	fRemaining = size;

146	148	fFilterOffset= fInvocationOffset;
147	149	fLastCompletionOffset= fFilterOffset;
148	150	// start invocation of processors as Futures, and make them populate the proposals upon completion
149		List<ICompletionProposal> computedProposals = Collections.synchronizedList(new ArrayList<>());
150	151	fFutures= buildCompletionFuturesOrJobs(fInvocationOffset);
151		List<CompletableFuture<Void>> populateFutures = new ArrayList<>(fFutures.size());
152		for (CompletableFuture<List<ICompletionProposal>> future : fFutures) {
153		populateFutures.add(future.thenAccept(proposals ->
154		computedProposals.addAll(proposals)
155		));
156		}
157
158		long requestBeginningTimestamp = System.currentTimeMillis();
159		long stillRemainingThreeshold = MAX_WAIT_IN_MS;
160		for (CompletableFuture<?> future : populateFutures) {
161		try {
162		future.get(stillRemainingThreeshold, TimeUnit.MILLISECONDS);
163		} catch (TimeoutException \| ExecutionException \| InterruptedException ex) {
164		// future failed or took more time than we want to wait
	152	runFutures(fInvocationOffset, null, true, autoActivated, true);
	153	} else {
	154	fLastCompletionOffset= fFilterOffset;
	155	handleRepeatedInvocation();
	156	}
	157
	158	return getErrorMessage();
	159	}
	160
	161	@Override
	162	void handleRepeatedInvocation() {
	163	cancelFutures();
	164	fFutures= buildCompletionFuturesOrJobs(fInvocationOffset);
	165	runFutures(fInvocationOffset, null, false, false, false);
	166	}
	167
	168	private List<ICompletionProposal> runFutures(int offset, Consumer<List<ICompletionProposal>> callback, boolean createSelector, boolean autoActivated, boolean autoInsert) {
	169	List<ICompletionProposal> computedProposals= Collections.synchronizedList(new ArrayList<>());
	170	List<CompletableFuture<Void>> populateFutures= new ArrayList<>(fFutures.size());
	171	for (CompletableFuture<List<ICompletionProposal>> future : fFutures) {
	172	populateFutures.add(future.thenAccept(proposals -> computedProposals.addAll(proposals)));
	173	}
	174
	175	long requestBeginningTimestamp= System.currentTimeMillis();
	176	long stillRemainingThreeshold= MAX_WAIT_IN_MS;
	177	for (CompletableFuture<?> future : populateFutures) {
	178	try {
	179	future.get(stillRemainingThreeshold, TimeUnit.MILLISECONDS);
	180	} catch (TimeoutException \| ExecutionException \| InterruptedException ex) {
	181	// future failed or took more time than we want to wait
	182	}
	183	stillRemainingThreeshold= MAX_WAIT_IN_MS - (System.currentTimeMillis() - requestBeginningTimestamp);
	184	if (stillRemainingThreeshold < 0) {
	185	// we already spent too much time (more than MAX_WAIT_IN_MS), stop waiting.
	186	break;
	187	}
	188	}
	189	fComputedProposals= computedProposals;
	190	if (stillRemainingThreeshold > 0) { // everything ready in time, go synchronous
	191	int count= computedProposals.size();
	192	if (count == 0 && hideWhenNoProposals(autoActivated))
	193	return computedProposals;
	194
	195	if (autoInsert && count == 1 && !autoActivated && canAutoInsert(computedProposals.get(0))) {
	196	insertProposal(computedProposals.get(0), (char) 0, 0, offset);
	197	hide();
	198	} else {
	199	if (createSelector) {
	200	createProposalSelector();
165	201	}
166		stillRemainingThreeshold = MAX_WAIT_IN_MS - (System.currentTimeMillis() - requestBeginningTimestamp);
167		if (stillRemainingThreeshold < 0) {
168		// we already spent too much time (more than MAX_WAIT_IN_MS), stop waiting.
169		break;
170		}
171		}
172		fComputedProposals = computedProposals;
173		if (stillRemainingThreeshold > 0) { // everything ready in time, go synchronous
174		int count= (computedProposals == null ? 0 : computedProposals.size());
175		if (count == 0 && hideWhenNoProposals(autoActivated))
176		return null;
177
178		if (count == 1 && !autoActivated && canAutoInsert(computedProposals.get(0))) {
179		insertProposal(computedProposals.get(0), (char) 0, 0, fInvocationOffset);
180		hide();
	202	if (callback != null) {
	203	callback.accept(computedProposals);
181	204	} else {
182		createProposalSelector();
183	205	setProposals(computedProposals, false);
184	206	displayProposals();
185	207	}
186		} else { // processors took too much time, go asynchronous
	208	}
	209	} else { // processors took too much time, go asynchronous
	210	if (createSelector) {
187	211	createProposalSelector();
188		ComputingProposal computingProposal= new ComputingProposal(fInvocationOffset, fFutures.size());
189		computedProposals.add(0, computingProposal);
190		fComputedProposals = computedProposals;
191		setProposals(fComputedProposals, false);
192		Set<CompletableFuture<Void>> remaining = Collections.synchronizedSet(new HashSet<>(populateFutures));
193		for (CompletableFuture<Void> populateFuture : populateFutures) {
194		populateFuture.thenRun(() -> {
195		remaining.removeIf(CompletableFuture::isDone);
196		computingProposal.setRemaining(remaining.size());
197		if (remaining.isEmpty()) {
198		computedProposals.remove(computingProposal);
	212	}
	213	ComputingProposal computingProposal= new ComputingProposal(offset, fFutures.size());
	214	computedProposals.add(0, computingProposal);
	215	setProposals(fComputedProposals, false);
	216	Set<CompletableFuture<Void>> remaining= Collections.synchronizedSet(new HashSet<>(populateFutures));
	217	for (CompletableFuture<Void> populateFuture : populateFutures) {
	218	populateFuture.thenRun(() -> {
	219	remaining.removeIf(CompletableFuture::isDone);
	220	computingProposal.setRemaining(remaining.size());
	221	if (remaining.isEmpty()) {
	222	computedProposals.remove(computingProposal);
	223	}
	224	List<ICompletionProposal> newProposals= new ArrayList<>(computedProposals);
	225	fComputedProposals= newProposals;
	226	Display.getDefault().asyncExec(() -> {
	227	if (autoInsert && !autoActivated && remaining.isEmpty() && newProposals.size() == 1 && canAutoInsert(newProposals.get(0))) {
	228	if (Helper.okToUse(fProposalShell)) {
	229	insertProposal(newProposals.get(0), (char) 0, 0, offset);
	230	hide();
	231	}
	232	return;
199	233	}
200		List<ICompletionProposal> newProposals = new ArrayList<>(computedProposals);
201		fComputedProposals = newProposals;
202		Display.getDefault().asyncExec(() -> {
	234	if (remaining.isEmpty() && callback != null) {
	235	callback.accept(newProposals);
	236	} else {
203	237	setProposals(newProposals, false);
204	238	displayProposals();
205		});
	239	}
206	240	});
207		}
	241	});
	242	}
	243	displayProposals();
	244	}
	245	return computedProposals;
	246	}
	247
	248	@Override
	249	public String incrementalComplete() {
	250	cancelFutures();
	251	if (Helper.okToUse(fProposalShell) && fFilteredProposals != null) {
	252	return super.incrementalComplete();
	253	}
	254	final Control control= fContentAssistSubjectControlAdapter.getControl();
	255
	256	if (fKeyListener == null)
	257	fKeyListener= new ProposalSelectionListener();
	258
	259	if (!Helper.okToUse(fProposalShell) && !control.isDisposed())
	260	fContentAssistSubjectControlAdapter.addKeyListener(fKeyListener);
	261
	262	fInvocationOffset= fContentAssistSubjectControlAdapter.getSelectedRange().x;
	263	fFilterOffset= fInvocationOffset;
	264	fLastCompletionOffset= fFilterOffset;
	265
	266	fFutures= buildCompletionFuturesOrJobs(fInvocationOffset);
	267	fFilteredProposals= runFutures(fInvocationOffset, (List<ICompletionProposal> proposals) -> {
	268	ensureDocumentListenerInstalled();
	269	if (proposals.size() > 0 && completeCommonPrefix()) {
	270	hide();
	271	} else {
	272	fFilteredProposals= proposals;
	273	setProposals(proposals, false);
208	274	displayProposals();
209	275	}
210		} else {
211		fLastCompletionOffset= fFilterOffset;
212		handleRepeatedInvocation();
213		}
214
	276	}, true, false, true);
215	277	return getErrorMessage();
216	278	}
217
218		@Override
219		public void hide() {
220		super.hide();
	279
	280	@Override
	281	List<ICompletionProposal> computeProposals(int offset) {
	282	if (fProposalShell != null) {
	283	fProposalShell.dispose();
	284	}
	285	showProposals(true);
	286	return fComputedProposals;
	287	}
	288
	289	@Override
	290	void createProposalSelector() {
	291	super.createProposalSelector();
	292	fProposalShell.addDisposeListener(e -> cancelFutures());
	293	}
	294
	295	void cancelFutures() {
221	296	if (fFutures != null) {
222	297	for (Future<?> future : fFutures) {
223	298	future.cancel(true);
224	299	}
225		}
	300	fFutures= null;
	301	}
	302	}
	303
	304	@Override
	305	protected List<ICompletionProposal> computeFilteredProposals(int offset, DocumentEvent event) {
	306	if(fComputedProposals != null && fComputedProposals.size() > 0 && fComputedProposals.get(0) instanceof ComputingProposal) {
	307	Set<CompletableFuture<List<ICompletionProposal>>> remaining = Collections.synchronizedSet(new HashSet<>(fFutures));
	308	for (CompletableFuture<List<ICompletionProposal>> future : fFutures) {
	309	future.thenRun(() -> {
	310	remaining.removeIf(CompletableFuture::isDone);
	311	if (remaining.isEmpty()) {
	312	filterProposals();
	313	}
	314	});
	315	}
	316	return fComputedProposals;
	317	}
	318	return super.computeFilteredProposals(offset, event);
	319	}
	320
	321	@Override
	322	public void hide() {
	323	super.hide();
	324	cancelFutures();
226	325	}
227	326
228	327	protected List<CompletableFuture<List<ICompletionProposal>>> buildCompletionFuturesOrJobs(int invocationOffset) {

237	336	}
238	337	List<CompletableFuture<List<ICompletionProposal>>> futures = new ArrayList<>(processors.size());
239	338	for (IContentAssistProcessor processor : processors) {
240		futures.add(CompletableFuture.supplyAsync(() ->
241		Arrays.asList(processor.computeCompletionProposals(fViewer, invocationOffset))
242		));
	339	futures.add(CompletableFuture.supplyAsync(() -> {
	340	ICompletionProposal[] proposals= processor.computeCompletionProposals(fViewer, invocationOffset);
	341	if (proposals == null) {
	342	return Collections.emptyList();
	343	}
	344	return Arrays.asList(proposals);
	345	}));
243	346	}
244	347	return futures;
245	348	}

255	358	}
256	359	return IDocument.DEFAULT_CONTENT_TYPE;
257	360	}
	361
258	362	}

+30

-23

org.eclipse.jface.text/src/org/eclipse/jface/text/contentassist/CompletionProposalPopup.java less more

74	74	import org.eclipse.jface.internal.text.InformationControlReplacer;
75	75	import org.eclipse.jface.internal.text.TableOwnerDrawSupport;
76	76	import org.eclipse.jface.preference.JFacePreferences;
	77	import org.eclipse.jface.resource.JFaceColors;
77	78	import org.eclipse.jface.resource.JFaceResources;
78	79	import org.eclipse.jface.util.Geometry;
79	80	import org.eclipse.jface.viewers.StyledString;

288	289	/** Listener filling the document event queue. */
289	290	private IDocumentListener fDocumentListener;
290	291	/** The filter list of proposals. */
291		private List<ICompletionProposal> fFilteredProposals;
	292	List<ICompletionProposal> fFilteredProposals;
292	293	/** The computed list of proposals. */
293	294	List<ICompletionProposal> fComputedProposals;
294	295	/** The offset for which the proposals have been computed. */

551	552	* @param offset the offset
552	553	* @return the completion proposals available at this offset, never null
553	554	*/
554		private List<ICompletionProposal> computeProposals(int offset) {
	555	List<ICompletionProposal> computeProposals(int offset) {
555	556	ICompletionProposal[] completionProposals;
556	557	if (fContentAssistSubjectControl != null) {
557	558	completionProposals= fContentAssistant.computeCompletionProposals(fContentAssistSubjectControl, offset);

653	654	}
654	655	});
655	656
656		fProposalShell.setBackground(control.getDisplay().getSystemColor(SWT.COLOR_GRAY));
657
658		Color c= getBackgroundColor(control);
659		fProposalTable.setBackground(c);
660
661		c= getForegroundColor(control);
662		fProposalTable.setForeground(c);
	657	Color background= getBackgroundColor(control);
	658	if (background == null) {
	659	background= JFaceColors.getInformationViewerBackgroundColor(Display.getDefault());
	660	}
	661
	662	Color foreground= getForegroundColor(control);
	663	if (foreground == null) {
	664	foreground= JFaceColors.getInformationViewerBackgroundColor(Display.getDefault());
	665	}
	666
	667	fProposalShell.setBackground(background);
	668	fProposalTable.setBackground(background);
	669	fProposalTable.setForeground(foreground);
663	670
664	671	fProposalTable.addSelectionListener(new SelectionListener() {
665	672

1259	1266	*
1260	1267	* @since 3.2
1261	1268	*/
1262		private void ensureDocumentListenerInstalled() {
	1269	void ensureDocumentListenerInstalled() {
1263	1270	if (fDocumentListener == null) {
1264	1271	fDocumentListener= new IDocumentListener() {
1265	1272	@Override

1459	1466	* Filters the displayed proposal based on the given cursor position and the
1460	1467	* offset of the original invocation of the content assistant.
1461	1468	*/
1462		private void filterProposals() {
	1469	void filterProposals() {
1463	1470	if (!fIsFilterPending) {
1464	1471	fIsFilterPending= true;
1465	1472	Control control= fContentAssistSubjectControlAdapter.getControl();

1476	1483	* @return the set of filtered proposals
1477	1484	* @since 3.0
1478	1485	*/
1479		private List<ICompletionProposal> computeFilteredProposals(int offset, DocumentEvent event) {
	1486	List<ICompletionProposal> computeFilteredProposals(int offset, DocumentEvent event) {
1480	1487
1481	1488	if (offset == fInvocationOffset && event == null) {
1482	1489	fIsFilteredSubset= false;

1611	1618
1612	1619	if (count == 1 && canAutoInsert(fFilteredProposals.get(0))) {
1613	1620	insertProposal(fFilteredProposals.get(0), (char) 0, 0, fInvocationOffset);
1614		hide();
	1621	hide();
1615	1622	} else {
1616	1623	ensureDocumentListenerInstalled();
1617	1624	if (count > 0 && completeCommonPrefix())

1622	1629	setProposals(fComputedProposals, false);
1623	1630	displayProposals();
1624	1631	}
	1632	}
1625	1633	}
1626		}
1627	1634	});
1628	1635	}
1629	1636	return getErrorMessage();

1639	1646	* selector can be closed, <code>false</code> otherwise
1640	1647	* @since 3.0
1641	1648	*/
1642		private boolean completeCommonPrefix() {
	1649	boolean completeCommonPrefix() {
1643	1650
1644	1651	// 0: insert single proposals
1645	1652	if (fFilteredProposals.size() == 1) {

1655	1662	IDocument document= fContentAssistSubjectControlAdapter.getDocument();
1656	1663
1657	1664	// contains the common postfix in the case that there are any proposals matching our LHS
1658		StringBuffer rightCasePostfix= null;
	1665	StringBuilder rightCasePostfix= null;
1659	1666	List<ICompletionProposal> rightCase= new ArrayList<>();
1660	1667
1661	1668	boolean isWrongCaseMatch= false;

1665	1672	CharSequence wrongCasePrefix= null;
1666	1673	int wrongCasePrefixStart= 0;
1667	1674	// contains the common postfix of all case-insensitive matches
1668		StringBuffer wrongCasePostfix= null;
	1675	StringBuilder wrongCasePostfix= null;
1669	1676	List<ICompletionProposal> wrongCase= new ArrayList<>();
1670	1677
1671	1678	boolean hasMixedProposals= hasMixedProposals();

1688	1695	rightCase.add(proposal);
1689	1696	CharSequence newPostfix= insertion.subSequence(relativeCompletionOffset, insertion.length());
1690	1697	if (rightCasePostfix == null)
1691		rightCasePostfix= new StringBuffer(newPostfix.toString());
	1698	rightCasePostfix= new StringBuilder(newPostfix.toString());
1692	1699	else
1693	1700	truncatePostfix(rightCasePostfix, newPostfix, false);
1694	1701	} else if (i == 0 \|\| isWrongCaseMatch) {

1720	1727	newPostfix= insertion.subSequence(relativeCompletionOffset, insertion.length());
1721	1728	}
1722	1729	if (wrongCasePostfix == null)
1723		wrongCasePostfix= new StringBuffer(newPostfix.toString());
	1730	wrongCasePostfix= new StringBuilder(newPostfix.toString());
1724	1731	else
1725	1732	truncatePostfix(wrongCasePostfix, newPostfix, hasMixedProposals);
1726	1733	wrongCase.add(proposal);

1778	1785	try {
1779	1786	// 4: check if parts of the postfix are already in the document
1780	1787	int to= Math.min(document.getLength(), fFilterOffset + postfix.length());
1781		StringBuffer inDocument= new StringBuffer(document.get(fFilterOffset, to - fFilterOffset));
	1788	StringBuilder inDocument= new StringBuilder(document.get(fFilterOffset, to - fFilterOffset));
1782	1789	truncatePostfix(inDocument, postfix, hasMixedProposals);
1783	1790
1784	1791	// 5: replace and reveal

1863	1870	* @param sequence the characters to truncate with
1864	1871	* @param ignoreCase <code>true</code> to ignore case while comparing
1865	1872	*/
1866		private void truncatePostfix(StringBuffer buffer, CharSequence sequence, boolean ignoreCase) {
	1873	private void truncatePostfix(StringBuilder buffer, CharSequence sequence, boolean ignoreCase) {
1867	1874	// find common prefix
1868	1875	int min= Math.min(buffer.length(), sequence.length());
1869	1876	for (int c= 0; c < min; c++) {

1892	1899	*/
1893	1900	void setMessage(String message) {
1894	1901	Assert.isNotNull(message);
1895		if (isActive() && fMessageText != null)
	1902	if (isActive() && fMessageText != null && !fMessageText.isDisposed())
1896	1903	fMessageText.setText(message + " "); //$NON-NLS-1$
1897	1904	}
1898	1905

1915	1922	* @since 3.2
1916	1923	*/
1917	1924	public void setStatusLineVisible(boolean show) {
1918		if (!isActive() \|\| show == (fMessageText != null))
	1925	if (!isActive() \|\| show == (fMessageText != null && !fMessageText.isDisposed()))
1919	1926	return; // nothing to do
1920	1927
1921	1928	if (show) {

+9

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/contentassist/ContentAssistSubjectControlAdapter.java less more

7	7	* Contributors:
8	8	* IBM Corporation - initial API and implementation
9	9	* Mickael Istria (Red Hat Inc.) - [251156] Allow multiple contentAssitProviders internally & inheritance
	10	* Stephan Wahlbrink <sw@wahlbrink.eu> - Bug 512251 - Fix IllegalArgumentException in ContextInformationPopup
10	11	*******************************************************************************/
11	12	package org.eclipse.jface.text.contentassist;
12	13

117	118	if (fContentAssistSubjectControl != null)
118	119	return fContentAssistSubjectControl.getLineDelimiter();
119	120	return fViewer.getTextWidget().getLineDelimiter();
	121	}
	122
	123	public boolean isValidWidgetOffset(int widgetOffset) {
	124	if (fContentAssistSubjectControl != null) {
	125	IDocument document= fContentAssistSubjectControl.getDocument();
	126	return (widgetOffset >= 0 && widgetOffset <= document.getLength());
	127	}
	128	return (widgetOffset >= 0 && widgetOffset <= fViewer.getTextWidget().getCharCount());
120	129	}
121	130
122	131	@Override

+160

-95

org.eclipse.jface.text/src/org/eclipse/jface/text/contentassist/ContentAssistant.java less more

14	14	*******************************************************************************/
15	15	package org.eclipse.jface.text.contentassist;
16	16
	17	import java.util.ArrayList;
	18	import java.util.Arrays;
	19	import java.util.Collection;
17	20	import java.util.Collections;
18	21	import java.util.HashMap;
19	22	import java.util.LinkedHashSet;
	23	import java.util.List;
20	24	import java.util.Map;
	25	import java.util.Objects;
21	26	import java.util.Set;
	27	import java.util.function.Function;
22	28
23	29	import org.eclipse.swt.SWT;
24	30	import org.eclipse.swt.SWTError;

82	88	/**
83	89	* The standard implementation of the {@link IContentAssistant} interface. Usually, clients
84	90	* instantiate this class and configure it before using it.
85		*
	91	*
86	92	* Since 3.12, it can compute and display the proposals asynchronously when invoking
87	93	* {@link #ContentAssistant(boolean)} with <code>true</code>.
88	94	*/

1047	1053
1048	1054	/**
1049	1055	* Tells whether this content assistant allows to run asynchronous
1050		*
	1056	*
1051	1057	* @since 3.12
1052	1058	*/
1053	1059	private boolean fAsynchronous;

1069	1075	* context information above the location at which it was activated. If auto activation will be
1070	1076	* enabled, without further configuration steps, this content assistant is activated after a 500
1071	1077	* milliseconds delay. It uses the default partitioning.
1072		*
	1078	*
1073	1079	* @param asynchronous <true> if this content assistant should present the proposals
1074	1080	* asynchronously, <code>false</code> otherwise
1075	1081	* @since 3.12

1115	1121	else
1116	1122	fProcessors.put(contentType, Collections.singleton(processor));
1117	1123	}
1118
	1124
1119	1125	/**
1120	1126	* Registers a given content assist processor for a particular content type. If there is already
1121	1127	* a processor registered for this type, it is kept and the new processor is appended to the list

1187	1193	if (fProcessors == null)
1188	1194	return ""; //$NON-NLS-1$
1189	1195
1190		StringBuffer buf= new StringBuffer(5);
	1196	StringBuilder buf= new StringBuilder(5);
1191	1197	for (Set<IContentAssistProcessor> processorsForContentType : fProcessors.values()) {
1192	1198	for (IContentAssistProcessor processor : processorsForContentType) {
1193	1199	char[] triggers= processor.getCompletionProposalAutoActivationCharacters();

1908	1914	*
1909	1915	* @param viewer the text viewer
1910	1916	* @param offset a offset within the document
1911		* @return a content-assist processor or <code>null</code> if none exists
1912		* @since 3.0
1913		*/
1914		private IContentAssistProcessor getProcessor(ITextViewer viewer, int offset) {
	1917	* @return the content-assist processors or <code>null</code> if none exists
	1918	* @since 3.13
	1919	*/
	1920	private Set<IContentAssistProcessor> getProcessors(ITextViewer viewer, int offset) {
1915	1921	try {
1916	1922
1917	1923	IDocument document= viewer.getDocument();
1918	1924	String type= TextUtilities.getContentType(document, getDocumentPartitioning(), offset, true);
1919	1925
1920		return getContentAssistProcessor(type);
	1926	return getContentAssistProcessors(type);
1921	1927
1922	1928	} catch (BadLocationException x) {
1923	1929	}

1926	1932	}
1927	1933
1928	1934	/**
1929		* Returns the content assist processor for the content type of the specified document position.
	1935	* Returns the content assist processors for the content type of the specified document position.
1930	1936	*
1931	1937	* @param contentAssistSubjectControl the content assist subject control
1932	1938	* @param offset a offset within the document
1933		* @return a content-assist processor or <code>null</code> if none exists
1934		* @since 3.0
1935		*/
1936		private IContentAssistProcessor getProcessor(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
	1939	* @return the content-assist processors or <code>null</code> if none exists
	1940	* @since 3.13
	1941	*/
	1942	private Set<IContentAssistProcessor> getProcessors(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
1937	1943	try {
1938	1944
1939	1945	IDocument document= contentAssistSubjectControl.getDocument();

1943	1949	else
1944	1950	type= IDocument.DEFAULT_CONTENT_TYPE;
1945	1951
1946		return getContentAssistProcessor(type);
	1952	return getContentAssistProcessors(type);
1947	1953
1948	1954	} catch (BadLocationException x) {
1949	1955	}

1965	1971	final IContentAssistSubjectControl contentAssistSubjectControl, final int offset) {
1966	1972	fLastErrorMessage= null;
1967	1973
1968		final ICompletionProposal[][] result= { null };
1969
1970		final IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
1971		if (p instanceof ISubjectControlContentAssistProcessor) {
	1974	final List<ICompletionProposal> result= new ArrayList<>();
	1975	final Set<IContentAssistProcessor> processors= getProcessors(contentAssistSubjectControl, offset);
	1976	if (processors != null) {
	1977	processors.forEach(p -> {
	1978	if (p instanceof ISubjectControlContentAssistProcessor) {
	1979	// Ensure that the assist session ends cleanly even if the processor throws an exception.
	1980	SafeRunner.run(new ExceptionLoggingSafeRunnable(COMPLETION_ERROR_MESSAGE_KEY) {
	1981	@Override
	1982	public void run() throws Exception {
	1983	result.addAll(Arrays.asList( ((ISubjectControlContentAssistProcessor) p)
	1984	.computeCompletionProposals(contentAssistSubjectControl, offset)));
	1985	fLastErrorMessage= p.getErrorMessage();
	1986	}
	1987	});
	1988	}
	1989	});
	1990	}
	1991
	1992	return result.isEmpty() ? null : result.toArray(new ICompletionProposal[result.size()]);
	1993	}
	1994
	1995	/**
	1996	* Returns an array of completion proposals computed based on the specified document position.
	1997	* The position is used to determine the appropriate content assist processor to invoke.
	1998	*
	1999	* @param viewer the viewer for which to compute the proposals
	2000	* @param offset a document offset
	2001	* @return an array of completion proposals or <code>null</code> if no proposals are possible
	2002	* @see IContentAssistProcessor#computeCompletionProposals(ITextViewer, int)
	2003	*/
	2004	ICompletionProposal[] computeCompletionProposals(final ITextViewer viewer, final int offset) {
	2005	fLastErrorMessage= null;
	2006
	2007	final Set<IContentAssistProcessor> processors= getProcessors(viewer, offset);
	2008	final List<ICompletionProposal> res = new ArrayList<>();
	2009	if (processors != null && !processors.isEmpty()) {
1972	2010	// Ensure that the assist session ends cleanly even if the processor throws an exception.
1973	2011	SafeRunner.run(new ExceptionLoggingSafeRunnable(COMPLETION_ERROR_MESSAGE_KEY) {
1974	2012	@Override
1975	2013	public void run() throws Exception {
1976		result[0]= ((ISubjectControlContentAssistProcessor) p)
1977		.computeCompletionProposals(contentAssistSubjectControl, offset);
1978		fLastErrorMessage= p.getErrorMessage();
	2014	processors.forEach(p -> {
	2015	ICompletionProposal[] proposals= p.computeCompletionProposals(viewer, offset);
	2016	if (proposals != null) {
	2017	res.addAll(Arrays.asList(proposals));
	2018	}
	2019	fLastErrorMessage= p.getErrorMessage();
	2020	});
1979	2021	}
1980	2022	});
1981	2023	}
1982	2024
1983		return result[0];
1984		}
1985
1986		/**
1987		* Returns an array of completion proposals computed based on the specified document position.
1988		* The position is used to determine the appropriate content assist processor to invoke.
1989		*
1990		* @param viewer the viewer for which to compute the proposals
1991		* @param offset a document offset
1992		* @return an array of completion proposals or <code>null</code> if no proposals are possible
1993		* @see IContentAssistProcessor#computeCompletionProposals(ITextViewer, int)
1994		*/
1995		ICompletionProposal[] computeCompletionProposals(final ITextViewer viewer, final int offset) {
1996		fLastErrorMessage= null;
1997
1998		final ICompletionProposal[][] result= { null };
1999
2000		final IContentAssistProcessor p= getProcessor(viewer, offset);
2001		if (p != null) {
2002		// Ensure that the assist session ends cleanly even if the processor throws an exception.
2003		SafeRunner.run(new ExceptionLoggingSafeRunnable(COMPLETION_ERROR_MESSAGE_KEY) {
2004		@Override
2005		public void run() throws Exception {
2006		result[0]= p.computeCompletionProposals(viewer, offset);
2007		fLastErrorMessage= p.getErrorMessage();
2008		}
2009		});
2010		}
2011
2012		return result[0];
	2025	return res.isEmpty() ? null : res.toArray(new ICompletionProposal[res.size()]);
2013	2026	}
2014	2027
2015	2028	/**

2025	2038	IContextInformation[] computeContextInformation(final ITextViewer viewer, final int offset) {
2026	2039	fLastErrorMessage= null;
2027	2040
2028		final IContextInformation[][] result= { null };
2029
2030		final IContentAssistProcessor p= getProcessor(viewer, offset);
2031		if (p != null) {
	2041	final List<IContextInformation> result= new ArrayList<>();
	2042	final Set<IContentAssistProcessor> processors= getProcessors(viewer, offset);
	2043	if (processors != null && !processors.isEmpty()) {
2032	2044	// Ensure that the assist session ends cleanly even if the processor throws an exception.
2033	2045	SafeRunner.run(new ExceptionLoggingSafeRunnable(CONTEXT_ERROR_MESSAGE_KEY) {
2034	2046	@Override
2035	2047	public void run() throws Exception {
2036		result[0]= p.computeContextInformation(viewer, offset);
2037		fLastErrorMessage= p.getErrorMessage();
	2048	processors.forEach(p -> {
	2049	result.addAll(Arrays.asList(p.computeContextInformation(viewer, offset)));
	2050	fLastErrorMessage= p.getErrorMessage();
	2051	});
2038	2052	}
2039	2053	});
2040	2054	}
2041	2055
2042		return result[0];
	2056	return result.isEmpty() ? null : result.toArray(new IContextInformation[result.size()]);
2043	2057	}
2044	2058
2045	2059	/**

2057	2071	final IContentAssistSubjectControl contentAssistSubjectControl, final int offset) {
2058	2072	fLastErrorMessage= null;
2059	2073
2060		final IContextInformation[][] result= { null };
2061
2062		final IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
2063		if (p instanceof ISubjectControlContentAssistProcessor) {
2064		// Ensure that the assist session ends cleanly even if the processor throws an exception.
2065		SafeRunner.run(new ExceptionLoggingSafeRunnable(CONTEXT_ERROR_MESSAGE_KEY) {
2066		@Override
2067		public void run() throws Exception {
2068		result[0]= ((ISubjectControlContentAssistProcessor) p)
2069		.computeContextInformation(contentAssistSubjectControl, offset);
2070		fLastErrorMessage= p.getErrorMessage();
	2074	final List<IContextInformation> result= new ArrayList<>();
	2075	final Set<IContentAssistProcessor> processors = getProcessors(contentAssistSubjectControl, offset);
	2076	if (processors != null) {
	2077	processors.forEach(p -> {
	2078	if (p instanceof ISubjectControlContentAssistProcessor) {
	2079	// Ensure that the assist session ends cleanly even if the processor throws an exception.
	2080	SafeRunner.run(new ExceptionLoggingSafeRunnable(CONTEXT_ERROR_MESSAGE_KEY) {
	2081	@Override
	2082	public void run() throws Exception {
	2083	result.addAll(Arrays.asList( ((ISubjectControlContentAssistProcessor) p)
	2084	.computeContextInformation(contentAssistSubjectControl, offset)));
	2085	fLastErrorMessage= p.getErrorMessage();
	2086	}
	2087	});
2071	2088	}
2072	2089	});
2073	2090	}
2074	2091
2075		return result[0];
	2092	return result.isEmpty() ? null : result.toArray(new IContextInformation[result.size()]);
2076	2093	}
2077	2094
2078	2095	/**

2087	2104	* @since 3.0
2088	2105	*/
2089	2106	IContextInformationValidator getContextInformationValidator(ITextViewer viewer, int offset) {
2090		IContentAssistProcessor p= getProcessor(viewer, offset);
	2107	Set<IContentAssistProcessor> processors= getProcessors(viewer, offset);
	2108	if (processors == null \|\| processors.isEmpty()) {
	2109	return null;
	2110	}
	2111	// pick first one, arbitrary
	2112	IContentAssistProcessor p = processors.iterator().next();
2091	2113	return p != null ? p.getContextInformationValidator() : null;
2092	2114	}
2093	2115

2103	2125	* @since 3.0
2104	2126	*/
2105	2127	IContextInformationValidator getContextInformationValidator(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
2106		IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
	2128	Set<IContentAssistProcessor> processors= getProcessors(contentAssistSubjectControl, offset);
	2129	if (processors == null \|\| processors.isEmpty()) {
	2130	return null;
	2131	}
	2132	// pick first one, arbitrary
	2133	IContentAssistProcessor p = processors.iterator().next();
2107	2134	return p != null ? p.getContextInformationValidator() : null;
2108	2135	}
2109	2136

2151	2178	* @since 3.0
2152	2179	*/
2153	2180	char[] getCompletionProposalAutoActivationCharacters(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
2154		IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
2155		return p != null ? p.getCompletionProposalAutoActivationCharacters() : null;
	2181	return mergeResults(getProcessors(contentAssistSubjectControl, offset), IContentAssistProcessor::getCompletionProposalAutoActivationCharacters);
2156	2182	}
2157	2183
2158	2184	/**

2166	2192	* @see IContentAssistProcessor#getCompletionProposalAutoActivationCharacters()
2167	2193	*/
2168	2194	char[] getCompletionProposalAutoActivationCharacters(ITextViewer viewer, int offset) {
2169		IContentAssistProcessor p= getProcessor(viewer, offset);
2170		return p != null ? p.getCompletionProposalAutoActivationCharacters() : null;
	2195	return mergeResults(getProcessors(viewer, offset), IContentAssistProcessor::getCompletionProposalAutoActivationCharacters);
2171	2196	}
2172	2197
2173	2198	/**

2182	2207	* @since 3.0
2183	2208	*/
2184	2209	char[] getContextInformationAutoActivationCharacters(ITextViewer viewer, int offset) {
2185		IContentAssistProcessor p= getProcessor(viewer, offset);
2186		return p != null ? p.getContextInformationAutoActivationCharacters() : null;
	2210	return mergeResults(getProcessors(viewer, offset), IContentAssistProcessor::getContextInformationAutoActivationCharacters);
2187	2211	}
2188	2212
2189	2213	/**

2198	2222	* @since 3.0
2199	2223	*/
2200	2224	char[] getContextInformationAutoActivationCharacters(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
2201		IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
2202		return p != null ? p.getContextInformationAutoActivationCharacters() : null;
	2225	return mergeResults(getProcessors(contentAssistSubjectControl, offset), IContentAssistProcessor::getContextInformationAutoActivationCharacters);
	2226	}
	2227
	2228	private char[] mergeResults(Collection<IContentAssistProcessor> processors, Function<IContentAssistProcessor, char[]> f) {
	2229	if (processors == null) {
	2230	return null;
	2231	}
	2232	char[][] arrays = processors.stream()
	2233	.map(f)
	2234	.filter(Objects::nonNull)
	2235	.filter(array -> array.length > 0)
	2236	.toArray(char[][]::new);
	2237	if (arrays.length == 0) {
	2238	return null;
	2239	} else if (arrays.length == 1) {
	2240	return arrays[0];
	2241	} else {
	2242	LinkedHashSet<Character> res = new LinkedHashSet<>();
	2243	for (char[] current : arrays) {
	2244	for (char c : current) {
	2245	res.add(Character.valueOf(c));
	2246	}
	2247	}
	2248	char[] array = new char[res.size()];
	2249	int index = 0;
	2250	for (Character c : res) {
	2251	array[index] = c.charValue();
	2252	index++;
	2253	}
	2254	return array;
	2255	}
2203	2256	}
2204	2257
2205	2258	@Override

2442	2495	*/
2443	2496	void fireSessionBeginEvent(boolean isAutoActivated) {
2444	2497	if (fContentAssistSubjectControlAdapter != null && !isProposalPopupActive()) {
2445		IContentAssistProcessor processor= getProcessor(fContentAssistSubjectControlAdapter, fContentAssistSubjectControlAdapter.getSelectedRange().x);
2446		ContentAssistEvent event= new ContentAssistEvent(this, processor, isAutoActivated);
2447		for (ICompletionListener listener : fCompletionListeners) {
2448		listener.assistSessionStarted(event);
	2498	Set<IContentAssistProcessor> processors= getProcessors(fContentAssistSubjectControlAdapter, fContentAssistSubjectControlAdapter.getSelectedRange().x);
	2499	if (processors != null) {
	2500	processors.forEach(processor -> {
	2501	ContentAssistEvent event= new ContentAssistEvent(this, processor, isAutoActivated);
	2502	for (ICompletionListener listener : fCompletionListeners) {
	2503	listener.assistSessionStarted(event);
	2504	}
	2505	});
2449	2506	}
2450	2507	}
2451	2508	}

2457	2514	*/
2458	2515	void fireSessionRestartEvent() {
2459	2516	if (fContentAssistSubjectControlAdapter != null) {
2460		IContentAssistProcessor processor= getProcessor(fContentAssistSubjectControlAdapter, fContentAssistSubjectControlAdapter.getSelectedRange().x);
2461		ContentAssistEvent event= new ContentAssistEvent(this, processor);
2462		for (ICompletionListener listener : fCompletionListeners) {
2463		if (listener instanceof ICompletionListenerExtension)
2464		((ICompletionListenerExtension)listener).assistSessionRestarted(event);
	2517	Set<IContentAssistProcessor> processors= getProcessors(fContentAssistSubjectControlAdapter, fContentAssistSubjectControlAdapter.getSelectedRange().x);
	2518	if (processors != null) {
	2519	processors.forEach(processor -> {
	2520	ContentAssistEvent event= new ContentAssistEvent(this, processor);
	2521	for (ICompletionListener listener : fCompletionListeners) {
	2522	if (listener instanceof ICompletionListenerExtension)
	2523	((ICompletionListenerExtension)listener).assistSessionRestarted(event);
	2524	}
	2525	});
2465	2526	}
2466	2527	}
2467	2528	}

2473	2534	*/
2474	2535	void fireSessionEndEvent() {
2475	2536	if (fContentAssistSubjectControlAdapter != null) {
2476		IContentAssistProcessor processor= getProcessor(fContentAssistSubjectControlAdapter, fContentAssistSubjectControlAdapter.getSelectedRange().x);
2477		ContentAssistEvent event= new ContentAssistEvent(this, processor);
2478		for (ICompletionListener listener : fCompletionListeners) {
2479		listener.assistSessionEnded(event);
	2537	Set<IContentAssistProcessor> processors= getProcessors(fContentAssistSubjectControlAdapter, fContentAssistSubjectControlAdapter.getSelectedRange().x);
	2538	if (processors != null) {
	2539	processors.forEach(processor -> {
	2540	ContentAssistEvent event= new ContentAssistEvent(this, processor);
	2541	for (ICompletionListener listener : fCompletionListeners) {
	2542	listener.assistSessionEnded(event);
	2543	}
	2544	});
2480	2545	}
2481	2546	}
2482	2547	}

+30

-9

org.eclipse.jface.text/src/org/eclipse/jface/text/contentassist/ContextInformationPopup.java less more

6	6	*
7	7	* Contributors:
8	8	* IBM Corporation - initial API and implementation
	9	* Stephan Wahlbrink <sw@wahlbrink.eu> - Bug 512251 - Fix IllegalArgumentException in ContextInformationPopup
9	10	*******************************************************************************/
10	11	package org.eclipse.jface.text.contentassist;
11	12

273	274	* @since 3.0
274	275	*/
275	276	private void internalShowContextInfo(ContextFrame frame) {
276		if (frame != null) {
	277	if (frame != null && canShowFrame(frame)) {
277	278	fContextFrameStack.push(frame);
278	279	if (fContextFrameStack.size() == 1)
279	280	fLastContext= null;

332	333	*/
333	334	private boolean isLastFrame(ContextFrame frame) {
334	335	return frame != null && frame.equals(fLastContext);
	336	}
	337
	338	/**
	339	* Pre-checks if the given context frame can be (re)shown.
	340	*
	341	* The function checks if the frame has valid position data. It does not call the context
	342	* information validator.
	343	*
	344	* @param frame the frame to check
	345	* @return <code>true</code> if the context frame OK to use, otherwise <code>false</code>
	346	*/
	347	private boolean canShowFrame(ContextFrame frame) {
	348	return fContentAssistSubjectControlAdapter.isValidWidgetOffset(frame.fVisibleOffset);
335	349	}
336	350
337	351	/**

456	470	if (Helper.okToUse(fContextInfoPopup)) {
457	471
458	472	int size= fContextFrameStack.size();
459		if (size > 0) {
	473	while (size > 0) {
460	474	fLastContext= fContextFrameStack.pop();
461	475	-- size;
462		}
463
464		if (size > 0) {
465		ContextFrame current= fContextFrameStack.peek();
466		internalShowContextFrame(current, false);
467		} else {
468
	476
	477	if (size > 0) {
	478	ContextFrame current= fContextFrameStack.peek();
	479	if (canShowFrame(current)) {
	480	internalShowContextFrame(current, false);
	481	return;
	482	}
	483	// continue - try next
	484	}
	485	else {
	486	break;
	487	}
	488	}
	489	{
469	490	fContentAssistant.removeContentAssistListener(this, ContentAssistant.CONTEXT_INFO_POPUP);
470	491
471	492	if (fContentAssistSubjectControlAdapter.getControl() != null)

+7

-8

org.eclipse.jface.text/src/org/eclipse/jface/text/hyperlink/MultipleHyperlinkPresenter.java less more

271	271	@Override
272	272	public void mouseMove(MouseEvent e) {
273	273	if (fTable.equals(e.getSource())) {
274		Object o= fTable.getItem(new Point(e.x, e.y));
275		if (fLastItem == null ^ o == null) {
276		fTable.setCursor(o == null ? null : fTable.getDisplay().getSystemCursor(SWT.CURSOR_HAND));
	274	TableItem item= fTable.getItem(new Point(e.x, e.y));
	275	if (fLastItem == null ^ item == null) {
	276	fTable.setCursor(item == null ? null : fTable.getDisplay().getSystemCursor(SWT.CURSOR_HAND));
277	277	}
278		if (o instanceof TableItem) {
279		TableItem item= (TableItem) o;
280		if (!o.equals(fLastItem)) {
281		fLastItem= (TableItem) o;
	278	if (item != null) {
	279	if (!item.equals(fLastItem)) {
	280	fLastItem= item;
282	281	fTable.setSelection(new TableItem[] { fLastItem });
283	282	} else if (e.y < fTable.getItemHeight() / 4) {
284	283	// Scroll up

295	294	fTable.setSelection(new TableItem[] { fLastItem });
296	295	}
297	296	}
298		} else if (o == null) {
	297	} else {
299	298	fLastItem= null;
300	299	}
301	300	}

+1

-1

org.eclipse.jface.text/src/org/eclipse/jface/text/rules/WordPatternRule.java less more

25	25	/** The word detector used by this rule */
26	26	protected IWordDetector fDetector;
27	27	/** The internal buffer used for pattern detection */
28		private StringBuffer fBuffer= new StringBuffer();
	28	private StringBuilder fBuffer= new StringBuilder();
29	29
30	30	/**
31	31	* Creates a rule for the given starting and ending word

+1

-1

org.eclipse.jface.text/src/org/eclipse/jface/text/rules/WordRule.java less more

38	38	/** The table of predefined words and token for this rule. */
39	39	protected Map<String, IToken> fWords= new HashMap<>();
40	40	/** Buffer used for pattern detection. */
41		private StringBuffer fBuffer= new StringBuffer();
	41	private StringBuilder fBuffer= new StringBuilder();
42	42	/**
43	43	* Tells whether this rule is case sensitive.
44	44	* @since 3.3

+28

-17

org.eclipse.jface.text/src/org/eclipse/jface/text/source/AnnotationPainter.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2015 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

1454	1454	return new Region(vOffset, vLength);
1455	1455	}
1456	1456
1457		int widgetOffset;
1458		try {
1459		int widgetClippingStartOffset= fTextWidget.getOffsetAtLocation(new Point(0, event.y));
1460		int firstWidgetLine= fTextWidget.getLineAtOffset(widgetClippingStartOffset);
1461		widgetOffset= fTextWidget.getOffsetAtLine(firstWidgetLine);
1462		} catch (IllegalArgumentException ex1) {
	1457	int widgetOffset= -1;
	1458	int widgetClippingStartOffset= fTextWidget.getOffsetAtPoint(new Point(0, event.y));
	1459	if (widgetClippingStartOffset != -1) {
	1460	try {
	1461	int firstWidgetLine= fTextWidget.getLineAtOffset(widgetClippingStartOffset);
	1462	widgetOffset= fTextWidget.getOffsetAtLine(firstWidgetLine);
	1463	} catch (IllegalArgumentException ex) {
	1464	/* ignore; keep widgetOffset at -1 */
	1465	}
	1466	}
	1467	if (widgetOffset == -1) {
1463	1468	try {
1464	1469	int firstVisibleLine= JFaceTextUtil.getPartialTopIndex(fTextWidget);
1465	1470	widgetOffset= fTextWidget.getOffsetAtLine(firstVisibleLine);
1466		} catch (IllegalArgumentException ex2) { // above try code might fail too
	1471	} catch (IllegalArgumentException ex) { // above try code might fail
1467	1472	widgetOffset= 0;
1468	1473	}
1469	1474	}
1470	1475
1471		int widgetEndOffset;
1472		try {
1473		int widgetClippingEndOffset= fTextWidget.getOffsetAtLocation(new Point(0, event.y + event.height));
1474		int lastWidgetLine= fTextWidget.getLineAtOffset(widgetClippingEndOffset);
1475		widgetEndOffset= fTextWidget.getOffsetAtLine(lastWidgetLine + 1);
1476		} catch (IllegalArgumentException ex1) {
	1476	int widgetEndOffset= -1;
	1477	int widgetClippingEndOffset= fTextWidget.getOffsetAtPoint(new Point(0, event.y + event.height));
	1478	if (widgetClippingEndOffset != -1) {
	1479	try {
	1480	int lastWidgetLine= fTextWidget.getLineAtOffset(widgetClippingEndOffset);
	1481	widgetEndOffset= fTextWidget.getOffsetAtLine(lastWidgetLine + 1);
	1482	} catch (IllegalArgumentException ex1) {
	1483	/* ignore; keep widgetEndOffset at -1 */
	1484	}
	1485	}
	1486	if (widgetEndOffset == -1) {
1477	1487	// happens if the editor is not "full", e.g. the last line of the document is visible in the editor
1478	1488	try {
1479	1489	int lastVisibleLine= JFaceTextUtil.getPartialBottomIndex(fTextWidget);
1480		if (lastVisibleLine == fTextWidget.getLineCount() - 1)
	1490	if (lastVisibleLine == fTextWidget.getLineCount() - 1) {
1481	1491	// last line
1482	1492	widgetEndOffset= fTextWidget.getCharCount();
1483		else
	1493	} else {
1484	1494	widgetEndOffset= fTextWidget.getOffsetAtLine(lastVisibleLine + 1) - 1;
1485		} catch (IllegalArgumentException ex2) { // above try code might fail too
	1495	}
	1496	} catch (IllegalArgumentException ex) { // above try code might fail too
1486	1497	widgetEndOffset= fTextWidget.getCharCount();
1487	1498	}
1488	1499	}

+35

-26

org.eclipse.jface.text/src/org/eclipse/jface/text/source/AnnotationRulerColumn.java less more

19	19	import java.util.List;
20	20	import java.util.Map;
21	21	import java.util.Set;
	22	import java.util.function.Consumer;
22	23
23	24	import org.eclipse.swt.SWT;
24	25	import org.eclipse.swt.custom.StyledText;

49	50	import org.eclipse.jface.text.ITextListener;
50	51	import org.eclipse.jface.text.ITextViewer;
51	52	import org.eclipse.jface.text.ITextViewerExtension5;
52		import org.eclipse.jface.text.IViewportListener;
53	53	import org.eclipse.jface.text.JFaceTextUtil;
54	54	import org.eclipse.jface.text.Position;
55	55	import org.eclipse.jface.text.TextEvent;

69	69	/**
70	70	* Internal listener class.
71	71	*/
72		class InternalListener implements IViewportListener, IAnnotationModelListener, ITextListener {
73
74		@Override
75		public void viewportChanged(int verticalPosition) {
76		if (verticalPosition != fScrollPos)
77		redraw();
78		}
79
	72	class AnnotationsListener implements IAnnotationModelListener {
80	73	@Override
81	74	public void modelChanged(IAnnotationModel model) {
82	75	postRedraw();
83		}
84
85		@Override
86		public void textChanged(TextEvent e) {
87		if (e.getViewerRedrawState())
88		postRedraw();
89	76	}
90	77	}
91	78

138	125	/** The buffer for double buffering */
139	126	private Image fBuffer;
140	127	/** The internal listener */
141		private InternalListener fInternalListener= new InternalListener();
	128	private AnnotationsListener fAnnotationListener= new AnnotationsListener();
142	129	/** The width of this vertical ruler */
143	130	private int fWidth;
144	131	/** Switch for enabling/disabling the setModel method. */

191	178	*/
192	179	private MouseListener fMouseListener;
193	180
	181	private Consumer<StyledText> lineHeightChangeHandler= (t) -> postRedraw();
	182
	183	private ITextListener fLineListener = new ITextListener() {
	184	private int previousLineCount = -1;
	185
	186	@Override
	187	public void textChanged(TextEvent event) {
	188	if (event.getViewerRedrawState() && fCachedTextWidget.getLineCount() != previousLineCount) {
	189	previousLineCount= fCachedTextWidget.getLineCount();
	190	postRedraw();
	191	}
	192	}
	193	};
	194
194	195	/**
195	196	* Constructs this column with the given arguments.
196	197	*

203	204	this(width, annotationAccess);
204	205	fAllowSetModel= false;
205	206	fModel= model;
206		fModel.addAnnotationModelListener(fInternalListener);
	207	fModel.addAnnotationModelListener(fAnnotationListener);
207	208	}
208	209
209	210	/**

229	230	fWidth= width;
230	231	fAllowSetModel= false;
231	232	fModel= model;
232		fModel.addAnnotationModelListener(fInternalListener);
	233	fModel.addAnnotationModelListener(fAnnotationListener);
233	234	}
234	235
235	236	/**

336	337	});
337	338
338	339	if (fCachedTextViewer != null) {
339		fCachedTextViewer.addViewportListener(fInternalListener);
340		fCachedTextViewer.addTextListener(fInternalListener);
	340	VisibleLinesTracker.track(fCachedTextViewer, lineHeightChangeHandler);
	341	fCachedTextViewer.addTextListener(fLineListener);
341	342	// on word wrap toggle a "resized" ControlEvent is fired: suggest a redraw of the ruler
342	343	fCachedTextWidget.addControlListener(new ControlAdapter() {
343	344	@Override

505	506	private void handleDispose() {
506	507
507	508	if (fCachedTextViewer != null) {
508		fCachedTextViewer.removeViewportListener(fInternalListener);
509		fCachedTextViewer.removeTextListener(fInternalListener);
	509	VisibleLinesTracker.untrack(fCachedTextViewer, lineHeightChangeHandler);
	510	fCachedTextViewer.removeTextListener(fLineListener);
510	511	}
511	512
512	513	if (fModel != null)
513		fModel.removeAnnotationModelListener(fInternalListener);
	514	fModel.removeAnnotationModelListener(fAnnotationListener);
514	515
515	516	if (fBuffer != null) {
516	517	fBuffer.dispose();

520	521	fConfiguredAnnotationTypes.clear();
521	522	fAllowedAnnotationTypes.clear();
522	523	fAnnotationAccessExtension= null;
	524
523	525	}
524	526
525	527	/**

818	820	r.height= textBounds.height;
819	821	r.y = textBounds.y;
820	822	}
821
	823	// adjust the annotation position at the bottom of the line if line height has custom line height
	824	int defaultLineHeight= fCachedTextWidget.getLineHeight();
	825	int lineHeight= fCachedTextWidget.getLineHeight(offset);
	826	if (lineHeight > defaultLineHeight) {
	827	int adjust= lineHeight - defaultLineHeight;
	828	r.y+= adjust;
	829	r.height-= adjust;
	830	}
822	831	if (r.y < dimension.y && fAnnotationAccessExtension != null) // annotation within visible area
823	832	fAnnotationAccessExtension.paint(annotation, gc, fCanvas, r);
824	833	}

866	875	if (fAllowSetModel && model != fModel) {
867	876
868	877	if (fModel != null)
869		fModel.removeAnnotationModelListener(fInternalListener);
	878	fModel.removeAnnotationModelListener(fAnnotationListener);
870	879
871	880	fModel= model;
872	881
873	882	if (fModel != null)
874		fModel.addAnnotationModelListener(fInternalListener);
	883	fModel.addAnnotationModelListener(fAnnotationListener);
875	884
876	885	postRedraw();
877	886	}

+4

-4

org.eclipse.jface.text/src/org/eclipse/jface/text/source/DefaultAnnotationHover.java less more

89	89	}
90	90
91	91	if (fShowLineNumber && lineNumber > -1)
92		return JFaceTextMessages.getFormattedString("DefaultAnnotationHover.lineNumber", new String[] { Integer.toString(lineNumber + 1) }); //$NON-NLS-1$
	92	return JFaceTextMessages.getFormattedString("DefaultAnnotationHover.lineNumber", Integer.toString(lineNumber + 1)); //$NON-NLS-1$
93	93
94	94	return null;
95	95	}

130	130	* @return the formatted message
131	131	*/
132	132	protected String formatMultipleMessages(List<String> messages) {
133		StringBuffer buffer= new StringBuffer();
	133	StringBuilder buffer= new StringBuilder();
134	134	buffer.append(JFaceTextMessages.getString("DefaultAnnotationHover.multipleMarkers")); //$NON-NLS-1$
135	135
136	136	Iterator<String> e= messages.iterator();
137	137	while (e.hasNext()) {
138	138	buffer.append('\n');
139	139	String listItemText= e.next();
140		buffer.append(JFaceTextMessages.getFormattedString("DefaultAnnotationHover.listItem", new String[] { listItemText })); //$NON-NLS-1$
	140	buffer.append(JFaceTextMessages.getFormattedString("DefaultAnnotationHover.listItem", listItemText)); //$NON-NLS-1$
141	141	}
142	142	return buffer.toString();
143	143	}

169	169	if (value instanceof List) {
170	170	@SuppressWarnings("unchecked")
171	171	List<Object> messages= (List<Object>) value;
172		if (messages.contains(message))
	172	if (messages.contains(message))
173	173	return true;
174	174
175	175	messages.add(message);

+3

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/source/ISourceViewer.java less more

6	6	*
7	7	* Contributors:
8	8	* IBM Corporation - initial API and implementation
	9	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
9	10	*******************************************************************************/
10	11	package org.eclipse.jface.text.source;
11	12

45	46	* to the quick assist invocation context as well as the current annotation hover.</li>
46	47	* <li>{@link org.eclipse.jface.text.source.ISourceViewerExtension4} since version 3.4
47	48	* introducing API to access a minimal set of content assistant APIs.</li>
	49	* <li>{@link org.eclipse.jface.text.source.ISourceViewerExtension5} since version 3.13
	50	* introducing API to access minimal set of code mining APIs.</li>
48	51	* </ul></p>
49	52	* <p>
50	53	* Clients may implement this interface and its extension interfaces or use the

+60

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/source/ISourceViewerExtension5.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017, 2018 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
	9	*******************************************************************************/
	10	package org.eclipse.jface.text.source;
	11
	12	import org.eclipse.jface.text.codemining.ICodeMining;
	13	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
	14
	15	/**
	16	* Extension interface for {@link org.eclipse.jface.text.source.ISourceViewer}.
	17	* <p>
	18	* It introduces API to access a minimal set of code mining APIs.</li>
	19	* </p>
	20	*
	21	* @see ICodeMining
	22	* @see ICodeMiningProvider
	23	* @since 3.13
	24	*/
	25	public interface ISourceViewerExtension5 {
	26
	27	/**
	28	* Set the {@link AnnotationPainter} to use to draw code minings.
	29	*
	30	* @param painter the {@link AnnotationPainter} to use to draw code minings.
	31	*/
	32	void setCodeMiningAnnotationPainter(AnnotationPainter painter);
	33
	34	/**
	35	* Register the code mining providers.
	36	*
	37	* @param codeMiningProviders the code mining providers to register.
	38	*/
	39	void setCodeMiningProviders(ICodeMiningProvider[] codeMiningProviders);
	40
	41	/**
	42	* Returns <code>true</code> if there are code mining providers and <code>false</code>
	43	* otherwise.
	44	*
	45	* @return <code>true</code> if there are code mining providers and <code>false</code>
	46	* otherwise.
	47	*/
	48	boolean hasCodeMiningProviders();
	49
	50	/**
	51	* Update the code minings.
	52	*
	53	* Clients and implementors are responsible of calling this method when needed. A typical
	54	* use-case can be to run it upon completion of a reconcilier and after a job that would compute
	55	* all the necessary pre-requisites to insert code mining annotations.
	56	*/
	57	void updateCodeMinings();
	58
	59	}

+1

-1

org.eclipse.jface.text/src/org/eclipse/jface/text/source/JFaceTextMessages.java less more

56	56	* @return the formatted string
57	57	* @since 3.0
58	58	*/
59		public static String getFormattedString(String key, Object[] args) {
	59	public static String getFormattedString(String key, Object... args) {
60	60	String format= null;
61	61	try {
62	62	format= fgResourceBundle.getString(key);

+3

-3

org.eclipse.jface.text/src/org/eclipse/jface/text/source/LineChangeHover.java less more

46	46	*/
47	47	protected String formatSource(String content) {
48	48	if (content != null) {
49		StringBuffer sb= new StringBuffer(content);
	49	StringBuilder sb= new StringBuilder(content);
50	50	final String tabReplacement= getTabReplacement();
51	51	for (int pos= 0; pos < sb.length(); pos++) {
52	52	if (sb.charAt(pos) == '\t')

113	113	* the viewer).
114	114	* added controls how many lines are added - added lines are
115	115	*/
116		StringBuffer text = new StringBuffer();
	116	StringBuilder text = new StringBuilder();
117	117	int added= 0;
118	118	for (ILineDiffInfo info : diffInfos) {
119	119	String[] original= info.getOriginalText();

137	137	}
138	138	}
139	139
140		text = new StringBuffer(text.toString().trim());
	140	text = new StringBuilder(text.toString().trim());
141	141	if (text.length() == 0 && added-- > 0 && maxLines-- > 0) {
142	142	text.append("+ ");//$NON-NLS-1$
143	143	}

+1

-1

org.eclipse.jface.text/src/org/eclipse/jface/text/source/LineNumberChangeRulerColumn.java less more

124	124
125	125	@Override
126	126	protected String createDisplayString(int line) {
127		StringBuffer buffer= new StringBuffer();
	127	StringBuilder buffer= new StringBuilder();
128	128	if (fShowNumbers)
129	129	buffer.append(super.createDisplayString(line));
130	130	if (fCharacterDisplay && getModel() != null)

+30

-37

org.eclipse.jface.text/src/org/eclipse/jface/text/source/LineNumberRulerColumn.java less more

16	16
17	17	import java.lang.ref.WeakReference;
18	18	import java.util.Arrays;
	19	import java.util.function.Consumer;
19	20
20	21	import org.eclipse.swt.SWT;
21	22	import org.eclipse.swt.custom.StyledText;

54	55	import org.eclipse.jface.text.ITextViewer;
55	56	import org.eclipse.jface.text.ITextViewerExtension;
56	57	import org.eclipse.jface.text.ITextViewerExtension5;
57		import org.eclipse.jface.text.IViewportListener;
58	58	import org.eclipse.jface.text.JFaceTextUtil;
59	59	import org.eclipse.jface.text.TextEvent;
60	60

81	81	/**
82	82	* Internal listener class.
83	83	*/
84		class InternalListener implements IViewportListener, ITextListener {
	84	class InternalListener implements ITextListener {
85	85
86	86	/**
87	87	* @since 3.1

89	89	private boolean fCachedRedrawState= true;
90	90
91	91	@Override
92		public void viewportChanged(int verticalPosition) {
93		if (fCachedRedrawState && verticalPosition != fScrollPos)
94		redraw();
95		}
96
97		@Override
98	92	public void textChanged(TextEvent event) {
99	93
100	94	fCachedRedrawState= event.getViewerRedrawState();

106	100	layout(event.getViewerRedrawState());
107	101	return;
108	102	}
109
110		boolean viewerCompletelyShown= isViewerCompletelyShown();
111		if (viewerCompletelyShown \|\| fSensitiveToTextChanges \|\| event.getDocumentEvent() == null)
112		postRedraw();
113		fSensitiveToTextChanges= viewerCompletelyShown;
114	103	}
115	104	}
116	105

242	231	if (relativePosition.x < 0)
243	232	offset= lineInfo.getOffset();
244	233	else {
245		try {
246		int widgetOffset= fCachedTextWidget.getOffsetAtLocation(relativePosition);
	234	int widgetOffset= fCachedTextWidget.getOffsetAtPoint(relativePosition);
	235	if (widgetOffset != -1) {
247	236	Point p= fCachedTextWidget.getLocationAtOffset(widgetOffset);
248		if (p.x > relativePosition.x)
	237	if (p.x > relativePosition.x) {
249	238	widgetOffset--;
	239	}
250	240
251	241	// Convert to model offset
252	242	if (fCachedTextViewer instanceof ITextViewerExtension5) {
253	243	ITextViewerExtension5 extension= (ITextViewerExtension5)fCachedTextViewer;
254	244	offset= extension.widgetOffset2ModelOffset(widgetOffset);
255		} else
	245	} else {
256	246	offset= widgetOffset + fCachedTextViewer.getVisibleRegion().getOffset();
257
258		} catch (IllegalArgumentException ex) {
	247	}
	248	} else {
259	249	int lineEndOffset= lineInfo.getOffset() + lineInfo.getLength();
260	250
261	251	// Convert to widget offset

392	382	private StyledText fCachedTextWidget;
393	383	/** The columns canvas */
394	384	private Canvas fCanvas;
395		/** Cache for the actual scroll position in pixels */
396		private int fScrollPos;
397	385	/** The drawable for double buffering */
398	386	private Image fBuffer;
399	387	/** The internal listener */
400		private InternalListener fInternalListener= new InternalListener();
	388	private ITextListener fInternalListener= new InternalListener();
401	389	/** The font of this column */
402	390	private Font fFont;
403	391	/** The indentation cache */
404	392	private int[] fIndentation;
405		/** Indicates whether this column reacts on text change events */
406		private boolean fSensitiveToTextChanges= false;
407	393	/** The foreground color */
408	394	private Color fForeground;
409	395	/** The background color */

445	431	private WeakReference<Font> fLastFont;
446	432	private Font fLastZoomedFont;
447	433
	434	/**
	435	* Redraw the ruler handler called when a line height change.
	436	*
	437	* @since 3.13
	438	*/
	439	private Consumer<StyledText> lineHeightChangeHandler= (t) -> postRedraw();
448	440
449	441	/**
450	442	* Constructs a new vertical ruler column.

617	609	}
618	610	}
619	611	});
	612
	613	// track when StyledText is redrawn to check if some line height changed. In this case, the ruler must be redrawn
	614	// to draw line number with well height.
	615	VisibleLinesTracker.track(fCachedTextViewer, lineHeightChangeHandler);
620	616
621	617	fCanvas= new Canvas(parentControl, SWT.NO_FOCUS ) {
622	618	@Override

658	654	fCanvas.addMouseWheelListener(fMouseHandler);
659	655
660	656	if (fCachedTextViewer != null) {
661
662		fCachedTextViewer.addViewportListener(fInternalListener);
	657	VisibleLinesTracker.track(fCachedTextViewer, lineHeightChangeHandler);
663	658	fCachedTextViewer.addTextListener(fInternalListener);
	659
664	660
665	661	if (fFont == null) {
666	662	if (fCachedTextWidget != null && !fCachedTextWidget.isDisposed())

682	678	protected void handleDispose() {
683	679
684	680	if (fCachedTextViewer != null) {
685		fCachedTextViewer.removeViewportListener(fInternalListener);
686		fCachedTextViewer.removeTextListener(fInternalListener);
	681	VisibleLinesTracker.untrack(fCachedTextViewer, lineHeightChangeHandler);
687	682	}
688	683
689	684	if (fBuffer != null) {

712	707
713	708	if (fBuffer != null) {
714	709	Rectangle r= fBuffer.getBounds();
715		if (r.width != size.x \|\| r.height != size.y) {
	710	if (IS_MAC_BUG_516293 \|\| r.width != size.x \|\| r.height != size.y) {
716	711	fBuffer.dispose();
717	712	fBuffer= null;
718	713	}

755	750	gc.setBackground(getBackground(fCanvas.getDisplay()));
756	751	gc.fillRectangle(0, 0, width, height);
757	752
758		fScrollPos= fCachedTextWidget.getTopPixel();
759	753	doPaint(gc, visibleLines);
760	754	} finally {
761	755	gc.dispose();

766	760	gcImage.dispose();
767	761	return imageData;
768	762	});
769
	763
770	764	} else {
771	765	if (fBuffer == null)
772	766	fBuffer= new Image(fCanvas.getDisplay(), size.x, size.y);

780	774	gc.setBackground(getBackground(fCanvas.getDisplay()));
781	775	gc.fillRectangle(0, 0, size.x, size.y);
782	776
783		fScrollPos= fCachedTextWidget.getTopPixel();
784	777	doPaint(gc, visibleLines);
785	778	} finally {
786	779	gc.dispose();

794	787	* This method is not API and it is expected to disappear in Eclipse 4.8.
795	788	* Subclasses that want to take advantage of the unsupported workaround for bug 516258
796	789	* can re-implement this method and return true.
797		*
	790	*
798	791	* @return true iff this class supports the workaround for bug 516258
799		*
	792	*
800	793	* @nooverride This method is not intended to be re-implemented or extended by clients.
801	794	* @noreference This method is not intended to be referenced by clients.
802	795	* @since 3.12

809	802	* This method is not API and it is expected to disappear in Eclipse 4.8.
810	803	* Subclasses that want to take advantage of the unsupported workaround for bug 516258
811	804	* can override this method and store the given zoom level for later use.
812		*
	805	*
813	806	* @param zoom the zoom level to use for drawing operations
814		*
	807	*
815	808	* @nooverride This method is not intended to be re-implemented or extended by clients.
816	809	* @noreference This method is not intended to be referenced by clients.
817	810	* @since 3.12

819	812	protected void internalSetZoom(int zoom) {
820	813	// callback for subclasses
821	814	}
822
	815
823	816	/**
824	817	* Returns the view port height in lines.
825	818	*

+2

-1

org.eclipse.jface.text/src/org/eclipse/jface/text/source/MatchingCharacterPainter.java less more

248	248	gc.setForeground(fColor);
249	249
250	250	Rectangle bounds= fTextWidget.getTextBounds(offset, offset + length - 1);
	251	int height= fTextWidget.getCaret().getSize().y;
251	252
252	253	// draw box around line segment
253		gc.drawRectangle(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1);
	254	gc.drawRectangle(bounds.x, bounds.y + bounds.height - height, bounds.width - 1, height - 1);
254	255
255	256	// draw box around character area
256	257	// int widgetBaseline= fTextWidget.getBaseline();

+2

-2

org.eclipse.jface.text/src/org/eclipse/jface/text/source/OverviewRuler.java less more

1501	1501	if (fHeader.getToolTipText() != null)
1502	1502	return;
1503	1503
1504		StringBuffer overview = new StringBuffer();
	1504	StringBuilder overview = new StringBuilder();
1505	1505
1506	1506	for (int i= fAnnotationsSortedByLayer.size() -1; i >= 0; i--) {
1507	1507

1527	1527	if (overview.length() > 0) {
1528	1528	overview.append("\n"); //$NON-NLS-1$
1529	1529	}
1530		overview.append(JFaceTextMessages.getFormattedString("OverviewRulerHeader.toolTipTextEntry", new Object[] {annotationTypeLabel, Integer.valueOf(count)})); //$NON-NLS-1$
	1530	overview.append(JFaceTextMessages.getFormattedString("OverviewRulerHeader.toolTipTextEntry", annotationTypeLabel, Integer.valueOf(count))); //$NON-NLS-1$
1531	1531	}
1532	1532	}
1533	1533

+99

-2

org.eclipse.jface.text/src/org/eclipse/jface/text/source/SourceViewer.java less more

9	9	* Tom Eicher (Avaloq Evolution AG) - block selection mode
10	10	* Tom Hofmann (Perspectix AG) - bug 297572
11	11	* Sergey Prigogin (Google) - bug 441448
	12	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
12	13	*******************************************************************************/
13	14	package org.eclipse.jface.text.source;
14	15

27	28
28	29	import org.eclipse.jface.internal.text.NonDeletingPositionUpdater;
29	30	import org.eclipse.jface.internal.text.StickyHoverManager;
	31	import org.eclipse.jface.internal.text.codemining.CodeMiningManager;
30	32
31	33	import org.eclipse.jface.text.AbstractHoverInformationControlManager;
32	34	import org.eclipse.jface.text.BadLocationException;

48	50	import org.eclipse.jface.text.Position;
49	51	import org.eclipse.jface.text.Region;
50	52	import org.eclipse.jface.text.TextViewer;
	53	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
51	54	import org.eclipse.jface.text.contentassist.IContentAssistant;
52	55	import org.eclipse.jface.text.contentassist.IContentAssistantExtension2;
53	56	import org.eclipse.jface.text.contentassist.IContentAssistantExtension4;

63	66	import org.eclipse.jface.text.quickassist.IQuickAssistAssistant;
64	67	import org.eclipse.jface.text.quickassist.IQuickAssistInvocationContext;
65	68	import org.eclipse.jface.text.reconciler.IReconciler;
	69	import org.eclipse.jface.text.source.inlined.InlinedAnnotationSupport;
66	70
67	71	/**
68	72	* SWT based implementation of

81	85	* <p>
82	86	* Clients may subclass this class but should expect some breakage by future releases.</p>
83	87	*/
84		public class SourceViewer extends TextViewer implements ISourceViewer, ISourceViewerExtension, ISourceViewerExtension2, ISourceViewerExtension3, ISourceViewerExtension4 {
	88	public class SourceViewer extends TextViewer implements ISourceViewer, ISourceViewerExtension, ISourceViewerExtension2, ISourceViewerExtension3, ISourceViewerExtension4, ISourceViewerExtension5 {
85	89
86	90
87	91	/**

347	351
348	352	/**
349	353	* The overview ruler.
	354	*
350	355	* @since 2.1
351	356	*/
352	357	private IOverviewRuler fOverviewRuler;

355	360	* @since 2.1
356	361	*/
357	362	private boolean fIsOverviewRulerVisible;
358
	363	/**
	364	* The inlined annotation support used by code mining manager.
	365	*
	366	* @since 3.13
	367	*/
	368	private InlinedAnnotationSupport fInlinedAnnotationSupport;
	369	/**
	370	* The text viewer's code mining providers.
	371	*
	372	* @since 3.13
	373	*/
	374	private ICodeMiningProvider[] fCodeMiningProviders;
	375	/**
	376	* The text viewer's annotation painter to draw code mining annotations.
	377	*
	378	* @since 3.13
	379	*/
	380	private AnnotationPainter fAnnotationPainter;
	381	/**
	382	* The text viewer's code mining manager.
	383	*
	384	* @since 3.13
	385	*/
	386	private CodeMiningManager fCodeMiningManager;
359	387
360	388	/**
361	389	* Constructs a new source viewer. The vertical ruler is initially visible.

523	551	if (prefixes != null && prefixes.length > 0)
524	552	setDefaultPrefixes(prefixes, t);
525	553	}
	554	setCodeMiningProviders(configuration.getCodeMiningProviders(this));
526	555
527	556	activatePlugins();
528	557	}

730	759	}
731	760
732	761	setHyperlinkDetectors(null, SWT.NONE);
	762
	763	if (hasCodeMiningProviders()) {
	764	fCodeMiningManager.uninstall();
	765	fCodeMiningManager= null;
	766	}
	767	setCodeMiningProviders(null);
	768	if (fInlinedAnnotationSupport != null) {
	769	fInlinedAnnotationSupport.uninstall();
	770	fInlinedAnnotationSupport= null;
	771	}
733	772	}
734	773
735	774	@Override

1222	1261	return fVerticalRulerHoveringController.getCurrentAnnotationHover();
1223	1262	}
1224	1263
	1264	@Override
	1265	public void setCodeMiningProviders(ICodeMiningProvider[] codeMiningProviders) {
	1266	if (fCodeMiningProviders != null) {
	1267	for (ICodeMiningProvider contentMiningProvider : fCodeMiningProviders) {
	1268	contentMiningProvider.dispose();
	1269	}
	1270	}
	1271	boolean enable= codeMiningProviders != null && codeMiningProviders.length > 0;
	1272	fCodeMiningProviders= codeMiningProviders;
	1273	if (enable) {
	1274	if (fCodeMiningManager != null) {
	1275	fCodeMiningManager.setCodeMiningProviders(fCodeMiningProviders);
	1276	}
	1277	ensureCodeMiningManagerInstalled();
	1278	} else {
	1279	if (fCodeMiningManager != null) {
	1280	fCodeMiningManager.uninstall();
	1281	}
	1282	fCodeMiningManager= null;
	1283	}
	1284	}
	1285
	1286	/**
	1287	* Ensures that the code mining manager has been
	1288	* installed if a content mining provider is available.
	1289	*
	1290	* @since 3.13
	1291	*/
	1292	private void ensureCodeMiningManagerInstalled() {
	1293	if (fCodeMiningProviders != null && fCodeMiningProviders.length > 0 && fAnnotationPainter != null) {
	1294	if (fInlinedAnnotationSupport == null) {
	1295	fInlinedAnnotationSupport= new InlinedAnnotationSupport();
	1296	fInlinedAnnotationSupport.install(this, fAnnotationPainter);
	1297	}
	1298	fCodeMiningManager= new CodeMiningManager(this, fInlinedAnnotationSupport, fCodeMiningProviders);
	1299	// now trigger an update
	1300	updateCodeMinings();
	1301	}
	1302	}
	1303
	1304	@Override
	1305	public boolean hasCodeMiningProviders() {
	1306	return fCodeMiningManager != null; // manager always has at least one provider
	1307	}
	1308
	1309	@Override
	1310	public void updateCodeMinings() {
	1311	if (hasCodeMiningProviders()) {
	1312	fCodeMiningManager.run();
	1313	}
	1314	}
	1315
	1316	@Override
	1317	public void setCodeMiningAnnotationPainter(AnnotationPainter painter) {
	1318	fAnnotationPainter= painter;
	1319	ensureCodeMiningManagerInstalled();
	1320	}
	1321
1225	1322	}

+16

-1

org.eclipse.jface.text/src/org/eclipse/jface/text/source/SourceViewerConfiguration.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2008 IBM Corporation and others.
	1	* Copyright (c) 2000, 2017 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

6	6	*
7	7	* Contributors:
8	8	* IBM Corporation - initial API and implementation
	9	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
9	10	*******************************************************************************/
10	11	package org.eclipse.jface.text.source;
11	12

28	29	import org.eclipse.jface.text.ITextViewerExtension2;
29	30	import org.eclipse.jface.text.IUndoManager;
30	31	import org.eclipse.jface.text.TextViewerUndoManager;
	32	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
31	33	import org.eclipse.jface.text.contentassist.IContentAssistant;
32	34	import org.eclipse.jface.text.formatter.IContentFormatter;
33	35	import org.eclipse.jface.text.hyperlink.DefaultHyperlinkPresenter;

416	418	public int getHyperlinkStateMask(ISourceViewer sourceViewer) {
417	419	return SWT.MOD1;
418	420	}
	421
	422	/**
	423	* Returns the code mining providers which be used to draw code minings in the given source
	424	* viewer. This implementation always returns <code>null</code>.
	425	*
	426	* @param sourceViewer the source viewer to be configured by this configuration
	427	* @return an array with code mining providers or <code>null</code> if no code mining support
	428	* should be installed
	429	* @since 3.13
	430	*/
	431	public ICodeMiningProvider[] getCodeMiningProviders(ISourceViewer sourceViewer) {
	432	return null;
	433	}
419	434	}

+149

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/source/VisibleLinesTracker.java less more

	0	/**
	1	* Copyright (c) 2018 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - Bug 527720 - [CodeMining] Line number in vertical ruler can be not synchronized with line header annotation
	9	*/
	10	package org.eclipse.jface.text.source;
	11
	12	import java.util.ArrayList;
	13	import java.util.Collection;
	14	import java.util.function.Consumer;
	15
	16	import org.eclipse.swt.custom.StyledText;
	17	import org.eclipse.swt.events.PaintEvent;
	18	import org.eclipse.swt.events.PaintListener;
	19
	20	import org.eclipse.jface.text.ITextViewer;
	21	import org.eclipse.jface.text.JFaceTextUtil;
	22
	23	/**
	24	* Class to track line height change of visible lines of a given {@link StyledText}.
	25	*
	26	*/
	27	class VisibleLinesTracker implements PaintListener {
	28
	29	private static final String DATA_KEY= VisibleLinesTracker.class.getName();
	30
	31	/**
	32	* The viewer to track.
	33	*/
	34	private final ITextViewer viewer;
	35
	36	/**
	37	* The previous bottom line index.
	38	*/
	39	private int oldBottom= -1;
	40
	41	/**
	42	* The previous bottom line pixel.
	43	*/
	44	private int oldBottomPixel;
	45
	46	/**
	47	*
	48	* List of handler to call when a visible line height change.
	49	*/
	50	private final Collection<Consumer<StyledText>> handlers;
	51
	52	/**
	53	* Constructor to track line height change of visible lines of the {@link StyledText} of the
	54	* given viewer.
	55	*
	56	* @param viewer the viewer to track
	57	*/
	58	private VisibleLinesTracker(ITextViewer viewer) {
	59	this.viewer= viewer;
	60	this.handlers= new ArrayList<>();
	61	}
	62
	63	@Override
	64	public void paintControl(PaintEvent e) {
	65	StyledText textWidget= viewer.getTextWidget();
	66	// track if bottom line index or bottom line pixel changed.
	67	if (oldBottom == -1) {
	68	oldBottom= JFaceTextUtil.getPartialBottomIndex(viewer);
	69	oldBottomPixel= JFaceTextUtil.getLinePixel(textWidget, oldBottom);
	70	return;
	71	}
	72	int newBottom= JFaceTextUtil.getPartialBottomIndex(viewer);
	73	if (newBottom != oldBottom) {
	74	oldBottom= newBottom;
	75	oldBottomPixel= JFaceTextUtil.getLinePixel(textWidget, oldBottom);
	76	handlers.forEach(handler -> handler.accept(textWidget));
	77	return;
	78	}
	79	int newBottomPixel= JFaceTextUtil.getLinePixel(textWidget, newBottom);
	80	if (newBottomPixel != oldBottomPixel) {
	81	oldBottomPixel= newBottomPixel;
	82	handlers.forEach(handler -> handler.accept(textWidget));
	83	return;
	84	}
	85	}
	86
	87	/**
	88	* Track the line height change of the {@link StyledText} of the given handler an call the given
	89	* handler.
	90	*
	91	* @param viewer the viewer to track
	92	* @param handler the handler to call when line height change.
	93	*/
	94	static void track(ITextViewer viewer, Consumer<StyledText> handler) {
	95	StyledText textWidget= viewer != null ? viewer.getTextWidget() : null;
	96	if (textWidget == null) {
	97	return;
	98	}
	99	VisibleLinesTracker tracker= (VisibleLinesTracker) textWidget.getData(DATA_KEY);
	100	if (tracker == null) {
	101	tracker= new VisibleLinesTracker(viewer);
	102	textWidget.setData(DATA_KEY, tracker);
	103	}
	104	tracker.addHandler(handler);
	105	}
	106
	107	/**
	108	* Untrack the line height change of the {@link StyledText} of the given handler an call the
	109	* given handler.
	110	*
	111	* @param viewer the viewer to track
	112	* @param handler the handler to call when line height change.
	113	*/
	114	static void untrack(ITextViewer viewer, Consumer<StyledText> handler) {
	115	StyledText textWidget= viewer != null ? viewer.getTextWidget() : null;
	116	if (textWidget == null) {
	117	return;
	118	}
	119	VisibleLinesTracker tracker= (VisibleLinesTracker) textWidget.getData(DATA_KEY);
	120	if (tracker != null) {
	121	tracker.removeHandler(handler);
	122	}
	123	}
	124
	125	/**
	126	* Add the given handler.
	127	*
	128	* @param handler the handler to call when a visible line height change.
	129	*/
	130	private void addHandler(Consumer<StyledText> handler) {
	131	if (handlers.isEmpty()) {
	132	viewer.getTextWidget().addPaintListener(this);
	133	}
	134	handlers.add(handler);
	135	}
	136
	137	/**
	138	* Remove the given handler.
	139	*
	140	* @param handler the handler to call when a visible line height change.
	141	*/
	142	private void removeHandler(Consumer<StyledText> handler) {
	143	handlers.remove(handler);
	144	if (handlers.isEmpty()) {
	145	viewer.getTextWidget().removePaintListener(this);
	146	}
	147	}
	148	}

+231

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/AbstractInlinedAnnotation.java less more

	0	/**
	1	* Copyright (c) 2017, 2018 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide inline annotations support - Bug 527675
	9	*/
	10	package org.eclipse.jface.text.source.inlined;
	11
	12	import java.util.function.Consumer;
	13
	14	import org.eclipse.swt.SWT;
	15	import org.eclipse.swt.custom.StyledText;
	16	import org.eclipse.swt.events.MouseEvent;
	17	import org.eclipse.swt.graphics.Color;
	18	import org.eclipse.swt.graphics.Font;
	19	import org.eclipse.swt.graphics.GC;
	20
	21	import org.eclipse.jface.text.ITextViewerExtension5;
	22	import org.eclipse.jface.text.Position;
	23	import org.eclipse.jface.text.source.Annotation;
	24	import org.eclipse.jface.text.source.ISourceViewer;
	25
	26	/**
	27	* Abstract class for inlined annotation.
	28	*
	29	* @since 3.13
	30	* @noimplement This interface is not intended to be implemented by clients.
	31	*/
	32	public abstract class AbstractInlinedAnnotation extends Annotation {
	33
	34	/**
	35	* The type of inlined annotations.
	36	*/
	37	public static final String TYPE= "org.eclipse.jface.text.source.inlined"; //$NON-NLS-1$
	38
	39	/**
	40	* The position where the annotation must be drawn.
	41	*/
	42	private final Position position;
	43
	44	/**
	45	* The {@link ISourceViewer} where the annotation must be drawn.
	46	*/
	47	private ISourceViewer fViewer;
	48
	49	/**
	50	* The {@link InlinedAnnotationSupport} which manages the annotation.
	51	*/
	52	private InlinedAnnotationSupport support;
	53
	54	int fX;
	55
	56	int fY;
	57
	58	/**
	59	* Inlined annotation constructor.
	60	*
	61	* @param position the position where the annotation must be drawn.
	62	* @param viewer the {@link ISourceViewer} where the annotation must be drawn.
	63	*/
	64	protected AbstractInlinedAnnotation(Position position, ISourceViewer viewer) {
	65	super(TYPE, false, ""); //$NON-NLS-1$
	66	this.position= position;
	67	fViewer= viewer;
	68	}
	69
	70	/**
	71	* Returns the position where the annotation must be drawn.
	72	*
	73	* @return the position where the annotation must be drawn.
	74	*/
	75	public Position getPosition() {
	76	return position;
	77	}
	78
	79	/**
	80	* Returns the {@link StyledText} widget where the annotation must be drawn.
	81	*
	82	* @return the {@link StyledText} widget where the annotation must be drawn.
	83	*/
	84	public StyledText getTextWidget() {
	85	return fViewer.getTextWidget();
	86	}
	87
	88	/**
	89	* Returns the {@link ISourceViewer} where the annotation must be drawn.
	90	*
	91	* @return the {@link ISourceViewer} where the annotation must be drawn.
	92	*/
	93	public ISourceViewer getViewer() {
	94	return fViewer;
	95	}
	96
	97	/**
	98	* Redraw the inlined annotation.
	99	*/
	100	public void redraw() {
	101	StyledText text= getTextWidget();
	102	InlinedAnnotationSupport.runInUIThread(text, (t) -> {
	103	Position pos= getPosition();
	104	int offset= pos.getOffset();
	105	ISourceViewer viewer= getViewer();
	106	if (viewer instanceof ITextViewerExtension5) {
	107	// adjust offset according folded content
	108	offset= ((ITextViewerExtension5) viewer).modelOffset2WidgetOffset(offset);
	109	}
	110	InlinedAnnotationDrawingStrategy.draw(this, null, t, offset, pos.getLength(), null);
	111	});
	112	}
	113
	114	/**
	115	* Draw the inlined annotation. By default it draw the text of the annotation with gray color.
	116	* User can override this method to draw anything.
	117	*
	118	* @param gc the graphics context
	119	* @param textWidget the text widget to draw on
	120	* @param offset the offset of the line
	121	* @param length the length of the line
	122	* @param color the color of the line
	123	* @param x the x position of the annotation
	124	* @param y the y position of the annotation
	125	*/
	126	public void draw(GC gc, StyledText textWidget, int offset, int length, Color color, int x, int y) {
	127	gc.setForeground(color);
	128	gc.setBackground(textWidget.getBackground());
	129	gc.drawString(getText(), x, y, true);
	130	}
	131
	132	/**
	133	* Called when mouse over the inlined annotation.
	134	*
	135	* @param e the mouse event
	136	*/
	137	public void onMouseHover(MouseEvent e) {
	138	StyledText styledText= (StyledText) e.widget;
	139	styledText.setCursor(styledText.getDisplay().getSystemCursor(SWT.CURSOR_HAND));
	140	}
	141
	142	/**
	143	* Called when mouse out the inlined annotation.
	144	*
	145	* @param e the mouse event
	146	*/
	147	public void onMouseOut(MouseEvent e) {
	148	StyledText styledText= (StyledText) e.widget;
	149	styledText.setCursor(null);
	150	}
	151
	152	public Consumer<MouseEvent> getAction(MouseEvent e) {
	153	return null;
	154	}
	155
	156	/**
	157	* Set the inlined annotation support which manages this annotation.
	158	*
	159	* @param support the inlined annotation support which manages this annotation.
	160	*/
	161	void setSupport(InlinedAnnotationSupport support) {
	162	this.support= support;
	163	}
	164
	165	/**
	166	* Return whether the annotation is in visible lines.
	167	*
	168	* @return <code>true</code> if the annotation is in visible lines and <code>false</code>
	169	* otherwise.
	170	*/
	171	protected boolean isInVisibleLines() {
	172	return support.isInVisibleLines(getPosition().getOffset());
	173	}
	174
	175	/**
	176	* Return whether the given offset is in visible lines.
	177	*
	178	* @param offset the offset
	179	* @return <code>true</code> if the given offset is in visible lines and <code>false</code>
	180	* otherwise.
	181	*/
	182	protected boolean isInVisibleLines(int offset) {
	183	return support.isInVisibleLines(offset);
	184	}
	185
	186	/**
	187	* Returns the font according the specified <code>style</code> that the receiver will use to
	188	* paint textual information.
	189	*
	190	* @param style the style of Font widget to get.
	191	* @return the receiver's font according the specified <code>style</code>
	192	*
	193	*/
	194	Font getFont(int style) {
	195	return support.getFont(style);
	196	}
	197
	198	/**
	199	* Set the location where the annotation is drawn.
	200	*
	201	* @param x the x coordinate where draw of annotation starts.
	202	* @param y the y coordinate where draw of annotation starts.
	203	*/
	204	void setLocation(int x, int y) {
	205	this.fX= x;
	206	this.fY= y;
	207	}
	208
	209	/**
	210	* Returns <code>true</code> if the point specified by the arguments is inside the annotation
	211	* specified by the receiver, and <code>false</code> otherwise.
	212	*
	213	* @param x the x coordinate of the point to test for containment
	214	* @param y the y coordinate of the point to test for containment
	215	* @return <code>true</code> if the annotation contains the point and <code>false</code>
	216	* otherwise
	217	*/
	218	boolean contains(int x, int y) {
	219	StyledText styledText= getTextWidget();
	220	GC gc= null;
	221	try {
	222	gc= new GC(styledText);
	223	return x >= fX && y >= fY && y <= fY + styledText.getLineHeight(position.getOffset()) && x <= fX + gc.stringExtent(getText()).x + 2 * gc.getFontMetrics().getAverageCharacterWidth();
	224	} finally {
	225	if (gc != null) {
	226	gc.dispose();
	227	}
	228	}
	229	}
	230	}

+341

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/InlinedAnnotationDrawingStrategy.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide inline annotations support - Bug 527675
	9	*/
	10	package org.eclipse.jface.text.source.inlined;
	11
	12	import org.eclipse.swt.custom.StyleRange;
	13	import org.eclipse.swt.custom.StyledText;
	14	import org.eclipse.swt.graphics.Color;
	15	import org.eclipse.swt.graphics.GC;
	16	import org.eclipse.swt.graphics.GlyphMetrics;
	17	import org.eclipse.swt.graphics.Point;
	18	import org.eclipse.swt.graphics.Rectangle;
	19
	20	import org.eclipse.jface.text.Position;
	21	import org.eclipse.jface.text.source.Annotation;
	22	import org.eclipse.jface.text.source.AnnotationPainter.IDrawingStrategy;
	23
	24	/**
	25	* {@link IDrawingStrategy} implementation to render {@link AbstractInlinedAnnotation}.
	26	*
	27	* @since 3.13
	28	*/
	29	class InlinedAnnotationDrawingStrategy implements IDrawingStrategy {
	30
	31	@Override
	32	public void draw(Annotation annotation, GC gc, StyledText textWidget, int offset, int length, Color color) {
	33	if (!(annotation instanceof AbstractInlinedAnnotation)) {
	34	return;
	35	}
	36	if (!((AbstractInlinedAnnotation) annotation).isInVisibleLines()) {
	37	// The annotation is not in visible lines, don't draw it.
	38	return;
	39	}
	40	InlinedAnnotationDrawingStrategy.draw((AbstractInlinedAnnotation) annotation, gc, textWidget, offset, length,
	41	color);
	42	}
	43
	44	/**
	45	* Draw the inlined annotation.
	46	*
	47	* @param annotation the annotation to be drawn
	48	* @param gc the graphics context, <code>null</code> when in clearing mode
	49	* @param textWidget the text widget to draw on
	50	* @param offset the offset of the line
	51	* @param length the length of the line
	52	* @param color the color of the line
	53	*/
	54	public static void draw(AbstractInlinedAnnotation annotation, GC gc, StyledText textWidget, int offset, int length,
	55	Color color) {
	56	if (annotation instanceof LineHeaderAnnotation) {
	57	draw((LineHeaderAnnotation) annotation, gc, textWidget, offset, length, color);
	58	} else {
	59	draw((LineContentAnnotation) annotation, gc, textWidget, offset, length, color);
	60	}
	61	}
	62
	63	/**
	64	* Draw the line header annotation in the line spacing of the previous line.
	65	*
	66	* @param annotation the annotation to be drawn
	67	* @param gc the graphics context, <code>null</code> when in clearing mode
	68	* @param textWidget the text widget to draw on
	69	* @param offset the offset of the line
	70	* @param length the length of the line
	71	* @param color the color of the line
	72	*/
	73	private static void draw(LineHeaderAnnotation annotation, GC gc, StyledText textWidget, int offset, int length,
	74	Color color) {
	75	StyleRange style= null;
	76	try {
	77	style= textWidget.getStyleRangeAtOffset(offset);
	78	} catch (Exception e) {
	79	return;
	80	}
	81	if (annotation.isMarkedDeleted() \|\| annotation.getPosition().isDeleted()) {
	82	// When annotation is deleted, update metrics to null to remove extra spaces of the line header annotation.
	83	if (style != null) {
	84	style.metrics= null;
	85	textWidget.setStyleRange(style);
	86	}
	87	return;
	88	}
	89	if (gc != null) {
	90	// Compute the location of the annotation
	91	Rectangle bounds= textWidget.getTextBounds(offset, offset);
	92	int x= bounds.x;
	93	int y= bounds.y;
	94
	95	// Colorize line spacing area with the background of StyledText to avoid having highlighted line color
	96	gc.setBackground(textWidget.getBackground());
	97	Rectangle client= textWidget.getClientArea();
	98	gc.fillRectangle(0, y, client.width, annotation.getHeight());
	99
	100	// Draw the line header annotation
	101	annotation.setLocation(x, y);
	102	annotation.draw(gc, textWidget, offset, length, color, x, y);
	103	int height= annotation.getHeight();
	104	if (height != 0) {
	105	// The inline annotation replaces one character by taking a place width
	106	// GlyphMetrics
	107	// Here we need to redraw this first character because GlyphMetrics clip this
	108	// character.
	109
	110	// FIXME: remove this code when we need not redraw the character (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=531769)
	111	// START TO REMOVE
	112	String s= textWidget.getText(offset, offset);
	113	Point charBounds= gc.stringExtent(s);
	114	int charWidth= charBounds.x;
	115	int charHeight= charBounds.y;
	116	annotation.setRedrawnCharacterWidth(charWidth);
	117	annotation.setRedrawnCharacterHeight(charHeight);
	118	// END TO REMOVE
	119
	120	StyleRange newStyle= updateStyle(annotation, style);
	121	if (newStyle != null) {
	122	textWidget.setStyleRange(newStyle);
	123	return;
	124	}
	125
	126	// FIXME: remove this code when we need not redraw the character (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=531769)
	127	// START TO REMOVE
	128	int charX= x + bounds.width - charWidth;
	129	int charY= y + bounds.height - textWidget.getLineHeight();
	130	if (style != null) {
	131	if (style.background != null) {
	132	gc.setBackground(style.background);
	133	gc.fillRectangle(charX, charY, charWidth + 1, bounds.height);
	134	}
	135	if (style.foreground != null) {
	136	gc.setForeground(style.foreground);
	137	} else {
	138	gc.setForeground(textWidget.getForeground());
	139	}
	140	gc.setFont(annotation.getFont(style.fontStyle));
	141	}
	142	gc.drawString(s, charX, charY, true);
	143	// END TO REMOVE
	144	} else if (style != null && style.metrics != null && style.metrics.ascent != 0) {
	145	// line header annotation had an height, reset it
	146	style.metrics= null;
	147	textWidget.setStyleRange(style);
	148	}
	149	} else {
	150	if (style != null && style.metrics != null) {
	151	// Here GlyphMetrics ascent is done, the redraw of the full line width is done to avoid annotation clipping
	152	Rectangle bounds= textWidget.getTextBounds(offset, offset);
	153	Rectangle client= textWidget.getClientArea();
	154	textWidget.redraw(0, bounds.y, client.width, bounds.height, false);
	155	} else {
	156	textWidget.redrawRange(offset, length, true);
	157	}
	158	}
	159	}
	160
	161	/**
	162	* Returns the style to apply with GlyphMetrics ascent only if needed.
	163	*
	164	* @param annotation the line header annotation
	165	* @param style the current style and null otherwise.
	166	* @return the style to apply with GlyphMetrics ascent only if needed.
	167	*/
	168	static StyleRange updateStyle(LineHeaderAnnotation annotation, StyleRange style) {
	169	int width= annotation.getRedrawnCharacterWidth();
	170	if (width == 0) {
	171	// Update GlyphMetrics only when mining was already drawn
	172	return null;
	173	}
	174	int height= annotation.getHeight();
	175	if (height == 0) {
	176	return null;
	177	}
	178	int fullHeight= height + annotation.getRedrawnCharacterHeight();
	179	if (style == null) {
	180	style= new StyleRange();
	181	Position position= annotation.getPosition();
	182	style.start= position.getOffset();
	183	style.length= 1;
	184	}
	185	GlyphMetrics metrics= style.metrics;
	186	if (!annotation.isMarkedDeleted()) {
	187	if (metrics == null) {
	188	metrics= new GlyphMetrics(fullHeight, 0, width);
	189	} else {
	190	if (metrics.ascent == fullHeight) {
	191	return null;
	192	}
	193	/**
	194	* We must create a new GlyphMetrics instance because comparison with similarTo used
	195	* later in StyledText#setStyleRange will compare the same (modified) and won't
	196	* realize an update happened.
	197	*/
	198	metrics= new GlyphMetrics(fullHeight, 0, width);
	199	}
	200	} else {
	201	metrics= null;
	202	}
	203	style.metrics= metrics;
	204	return style;
	205	}
	206
	207	/**
	208	* Draw the line content annotation inside line in the empty area computed by
	209	* {@link GlyphMetrics}.
	210	*
	211	* @param annotation the annotation to be drawn
	212	* @param gc the graphics context, <code>null</code> when in clearing mode
	213	* @param textWidget the text widget to draw on
	214	* @param offset the offset of the line
	215	* @param length the length of the line
	216	* @param color the color of the line
	217	*/
	218	private static void draw(LineContentAnnotation annotation, GC gc, StyledText textWidget, int offset, int length,
	219	Color color) {
	220	StyleRange style= null;
	221	try {
	222	style= textWidget.getStyleRangeAtOffset(offset);
	223	} catch (Exception e) {
	224	return;
	225	}
	226	if (annotation.isMarkedDeleted() \|\| annotation.getPosition().isDeleted()) {
	227	// When annotation is deleted, update metrics to null to remove extra spaces of the line content annotation.
	228	if (style != null) {
	229	style.metrics= null;
	230	textWidget.setStyleRange(style);
	231	}
	232	return;
	233	}
	234	if (gc != null) {
	235	// Compute the location of the annotation
	236	Rectangle bounds= textWidget.getTextBounds(offset, offset);
	237	int x= bounds.x;
	238	int y= bounds.y;
	239
	240	// Get size of the character where GlyphMetrics width is added
	241	String s= textWidget.getText(offset, offset);
	242	Point charBounds= gc.stringExtent(s);
	243	int charWidth= charBounds.x;
	244	int charHeight= charBounds.y;
	245
	246	// When line text has line header annotation, there is a space on the top, adjust the y by using char height
	247	y+= bounds.height - charHeight;
	248
	249	// Draw the line content annotation
	250	annotation.setLocation(x, y);
	251	annotation.draw(gc, textWidget, offset, length, color, x, y);
	252	int width= annotation.getWidth();
	253	if (width != 0) {
	254	// FIXME: remove this code when we need not redraw the character (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=531769)
	255	// START TO REMOVE
	256	annotation.setRedrawnCharacterWidth(charWidth);
	257	// END TO REMOVE
	258
	259	// Annotation takes place, add GlyphMetrics width to the style
	260	StyleRange newStyle= updateStyle(annotation, style);
	261	if (newStyle != null) {
	262	textWidget.setStyleRange(newStyle);
	263	return;
	264	}
	265
	266	// FIXME: remove this code when we need not redraw the character (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=531769)
	267	// START TO REMOVE
	268	// The inline annotation replaces one character by taking a place width
	269	// GlyphMetrics
	270	// Here we need to redraw this first character (if it's not a line delimiter) because GlyphMetrics clip this
	271	// character.
	272	if (!("\r".equals(s) \|\| "\n".equals(s))) { //$NON-NLS-1$ //$NON-NLS-2$
	273	int charX= x + bounds.width - charWidth;
	274	int charY= y;
	275	if (style != null) {
	276	if (style.background != null) {
	277	gc.setBackground(style.background);
	278	gc.fillRectangle(charX, charY, charWidth + 1, bounds.height);
	279	}
	280	if (style.foreground != null) {
	281	gc.setForeground(style.foreground);
	282	} else {
	283	gc.setForeground(textWidget.getForeground());
	284	}
	285	gc.setFont(annotation.getFont(style.fontStyle));
	286	}
	287	gc.drawString(s, charX, charY, true);
	288	}
	289	// END TO REMOVE
	290	} else if (style != null && style.metrics != null && style.metrics.width != 0) {
	291	// line content annotation had an , reset it
	292	style.metrics= null;
	293	textWidget.setStyleRange(style);
	294	}
	295	} else {
	296	textWidget.redrawRange(offset, length, true);
	297	}
	298	}
	299
	300	/**
	301	* Returns the style to apply with GlyphMetrics width only if needed.
	302	*
	303	* @param annotation the line content annotation
	304	* @param style the current style and null otherwise.
	305	* @return the style to apply with GlyphMetrics width only if needed.
	306	*/
	307	static StyleRange updateStyle(LineContentAnnotation annotation, StyleRange style) {
	308	int width= annotation.getWidth();
	309	if (width == 0) {
	310	return null;
	311	}
	312	int fullWidth= width + annotation.getRedrawnCharacterWidth();
	313	if (style == null) {
	314	style= new StyleRange();
	315	Position position= annotation.getPosition();
	316	style.start= position.getOffset();
	317	style.length= 1;
	318	}
	319	GlyphMetrics metrics= style.metrics;
	320	if (!annotation.isMarkedDeleted()) {
	321	if (metrics == null) {
	322	metrics= new GlyphMetrics(0, 0, fullWidth);
	323	} else {
	324	if (metrics.width == fullWidth) {
	325	return null;
	326	}
	327	/**
	328	* We must create a new GlyphMetrics instance because comparison with similarTo used
	329	* later in StyledText#setStyleRange will compare the same (modified) and won't
	330	* realize an update happened.
	331	*/
	332	metrics= new GlyphMetrics(0, 0, fullWidth);
	333	}
	334	} else {
	335	metrics= null;
	336	}
	337	style.metrics= metrics;
	338	return style;
	339	}
	340	}

+650

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/InlinedAnnotationSupport.java less more

	0	/**
	1	* Copyright (c) 2017, 2018 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide inline annotations support - Bug 527675
	9	*/
	10	package org.eclipse.jface.text.source.inlined;
	11
	12	import java.util.ArrayList;
	13	import java.util.Collections;
	14	import java.util.HashMap;
	15	import java.util.Iterator;
	16	import java.util.List;
	17	import java.util.Map;
	18	import java.util.Map.Entry;
	19	import java.util.Set;
	20	import java.util.function.Consumer;
	21
	22	import org.eclipse.swt.SWT;
	23	import org.eclipse.swt.custom.StyleRange;
	24	import org.eclipse.swt.custom.StyledText;
	25	import org.eclipse.swt.events.ControlEvent;
	26	import org.eclipse.swt.events.ControlListener;
	27	import org.eclipse.swt.events.MouseEvent;
	28	import org.eclipse.swt.events.MouseListener;
	29	import org.eclipse.swt.events.MouseMoveListener;
	30	import org.eclipse.swt.graphics.Color;
	31	import org.eclipse.swt.graphics.Device;
	32	import org.eclipse.swt.graphics.Font;
	33	import org.eclipse.swt.graphics.FontData;
	34	import org.eclipse.swt.graphics.GlyphMetrics;
	35	import org.eclipse.swt.widgets.Display;
	36
	37	import org.eclipse.core.runtime.Assert;
	38
	39	import org.eclipse.jface.text.BadLocationException;
	40	import org.eclipse.jface.text.DocumentEvent;
	41	import org.eclipse.jface.text.IDocument;
	42	import org.eclipse.jface.text.IDocumentListener;
	43	import org.eclipse.jface.text.IRegion;
	44	import org.eclipse.jface.text.ISynchronizable;
	45	import org.eclipse.jface.text.ITextPresentationListener;
	46	import org.eclipse.jface.text.ITextViewerExtension4;
	47	import org.eclipse.jface.text.IViewportListener;
	48	import org.eclipse.jface.text.JFaceTextUtil;
	49	import org.eclipse.jface.text.Position;
	50	import org.eclipse.jface.text.TextPresentation;
	51	import org.eclipse.jface.text.source.Annotation;
	52	import org.eclipse.jface.text.source.AnnotationPainter;
	53	import org.eclipse.jface.text.source.AnnotationPainter.IDrawingStrategy;
	54	import org.eclipse.jface.text.source.IAnnotationModel;
	55	import org.eclipse.jface.text.source.IAnnotationModelExtension;
	56	import org.eclipse.jface.text.source.IAnnotationModelExtension2;
	57	import org.eclipse.jface.text.source.ISourceViewer;
	58
	59	/**
	60	* Support to draw inlined annotations:
	61	*
	62	* <ul>
	63	* <li>line header annotation with {@link LineHeaderAnnotation}.</li>
	64	* <li>line content annotation with {@link LineContentAnnotation}.</li>
	65	* </ul>
	66	*
	67	* @since 3.13
	68	*/
	69	public class InlinedAnnotationSupport {
	70
	71	/**
	72	* The annotation inlined strategy singleton.
	73	*/
	74	private static final IDrawingStrategy INLINED_STRATEGY= new InlinedAnnotationDrawingStrategy();
	75
	76	/**
	77	* The annotation inlined strategy ID.
	78	*/
	79	private static final String INLINED_STRATEGY_ID= "inlined"; //$NON-NLS-1$
	80
	81	/**
	82	* The StyledText font normal, bold, italic and bold itlaic both.
	83	*/
	84	private Font regularFont, boldFont, italicFont, boldItalicFont;
	85
	86	/**
	87	* Listener used to update {@link GlyphMetrics} width style for {@link LineContentAnnotation}.
	88	*/
	89	private ITextPresentationListener updateStylesWidth;
	90
	91	/**
	92	* Class to update {@link GlyphMetrics} width style for {@link LineContentAnnotation}.
	93	*
	94	*/
	95	private class UpdateStylesWidth implements ITextPresentationListener {
	96
	97	@Override
	98	public void applyTextPresentation(TextPresentation textPresentation) {
	99	IAnnotationModel annotationModel= fViewer.getAnnotationModel();
	100	IRegion region= textPresentation.getExtent();
	101	((IAnnotationModelExtension2) annotationModel)
	102	.getAnnotationIterator(region.getOffset(), region.getLength(), true, true)
	103	.forEachRemaining(annotation -> {
	104	if (annotation instanceof LineContentAnnotation) {
	105	LineContentAnnotation ann= (LineContentAnnotation) annotation;
	106	StyleRange style= InlinedAnnotationDrawingStrategy.updateStyle(ann, null);
	107	if (style != null) {
	108	textPresentation.mergeStyleRange(style);
	109	}
	110	} else if (annotation instanceof LineHeaderAnnotation) {
	111	LineHeaderAnnotation ann= (LineHeaderAnnotation) annotation;
	112	StyleRange style= InlinedAnnotationDrawingStrategy.updateStyle(ann, null);
	113	if (style != null) {
	114	textPresentation.mergeStyleRange(style);
	115	}
	116	}
	117	});
	118	}
	119	}
	120
	121	/**
	122	* Tracker of start/end offset of visible lines.
	123	*/
	124	private VisibleLines visibleLines;
	125
	126	/**
	127	* Class to track start/end offset of visible lines.
	128	*
	129	*/
	130	private class VisibleLines implements IViewportListener, IDocumentListener, ControlListener {
	131
	132	private int startOffset;
	133
	134	private Integer endOffset;
	135
	136	public VisibleLines() {
	137	install();
	138	fViewer.getTextWidget().getDisplay().asyncExec(() -> {
	139	compute();
	140	});
	141	}
	142
	143	@Override
	144	public void viewportChanged(int verticalOffset) {
	145	compute();
	146	}
	147
	148	@Override
	149	public void documentAboutToBeChanged(DocumentEvent event) {
	150	endOffset= null;
	151	}
	152
	153	@Override
	154	public void documentChanged(DocumentEvent event) {
	155	// Do nothing
	156	}
	157
	158	@Override
	159	public void controlMoved(ControlEvent e) {
	160	// Do nothing
	161	}
	162
	163	@Override
	164	public void controlResized(ControlEvent e) {
	165	compute();
	166	}
	167
	168	@SuppressWarnings("boxing")
	169	private void compute() {
	170	startOffset= getInclusiveTopIndexStartOffset();
	171	endOffset= getExclusiveBottomIndexEndOffset();
	172	}
	173
	174	/**
	175	* Returns the document offset of the upper left corner of the source viewer's view port,
	176	* possibly including partially visible lines.
	177	*
	178	* @return the document offset if the upper left corner of the view port
	179	*/
	180	private int getInclusiveTopIndexStartOffset() {
	181	if (fViewer != null && fViewer.getTextWidget() != null && !fViewer.getTextWidget().isDisposed()) {
	182	int top= JFaceTextUtil.getPartialTopIndex(fViewer);
	183	try {
	184	IDocument document= fViewer.getDocument();
	185	return document.getLineOffset(top);
	186	} catch (BadLocationException x) {
	187	// Do nothing
	188	}
	189	}
	190	return -1;
	191	}
	192
	193	/**
	194	* Returns the first invisible document offset of the lower right corner of the source
	195	* viewer's view port, possibly including partially visible lines.
	196	*
	197	* @return the first invisible document offset of the lower right corner of the view port
	198	*/
	199	private int getExclusiveBottomIndexEndOffset() {
	200	if (fViewer != null && fViewer.getTextWidget() != null && !fViewer.getTextWidget().isDisposed()) {
	201	int bottom= JFaceTextUtil.getPartialBottomIndex(fViewer);
	202	try {
	203	IDocument document= fViewer.getDocument();
	204	if (bottom >= document.getNumberOfLines()) {
	205	bottom= document.getNumberOfLines() - 1;
	206	}
	207	return document.getLineOffset(bottom) + document.getLineLength(bottom);
	208	} catch (BadLocationException x) {
	209	// Do nothing
	210	}
	211	}
	212	return -1;
	213	}
	214
	215	/**
	216	* Return whether the given offset is in visible lines.
	217	*
	218	* @param offset the offset
	219	* @return <code>true</code> if the given offset is in visible lines and <code>false</code>
	220	* otherwise.
	221	*/
	222	@SuppressWarnings("boxing")
	223	boolean isInVisibleLines(int offset) {
	224	if (endOffset == null) {
	225	Display display= fViewer.getTextWidget().getDisplay();
	226	if (display.getThread() == Thread.currentThread()) {
	227	endOffset= getExclusiveBottomIndexEndOffset();
	228	} else {
	229	display.syncExec(() -> endOffset= getExclusiveBottomIndexEndOffset());
	230	}
	231	}
	232	return offset >= startOffset && offset <= endOffset;
	233	}
	234
	235	/**
	236	* Uninstall visible lines
	237	*/
	238	void uninstall() {
	239	if (fViewer != null) {
	240	fViewer.removeViewportListener(this);
	241	if (fViewer.getDocument() != null) {
	242	fViewer.getDocument().removeDocumentListener(this);
	243	}
	244	if (fViewer.getTextWidget() != null) {
	245	fViewer.getTextWidget().removeControlListener(this);
	246	}
	247	}
	248	}
	249
	250	void install() {
	251	fViewer.addViewportListener(this);
	252	fViewer.getDocument().addDocumentListener(this);
	253	fViewer.getTextWidget().addControlListener(this);
	254	}
	255	}
	256
	257	private class MouseTracker implements MouseMoveListener, MouseListener {
	258
	259	private AbstractInlinedAnnotation fAnnotation;
	260
	261	private Consumer<MouseEvent> fAction;
	262
	263	private void update(MouseEvent e) {
	264	fAnnotation= null;
	265	fAction= null;
	266	AbstractInlinedAnnotation annotation= getInlinedAnnotationAtPoint(fViewer, e.x, e.y);
	267	if (annotation != null) {
	268	Consumer<MouseEvent> action= annotation.getAction(e);
	269	if (action != null) {
	270	fAnnotation= annotation;
	271	fAction= action;
	272	}
	273	}
	274	}
	275
	276	@Override
	277	public void mouseMove(MouseEvent e) {
	278	AbstractInlinedAnnotation oldAnnotation= fAnnotation;
	279	update(e);
	280	if (oldAnnotation != null) {
	281	if (oldAnnotation.equals(fAnnotation)) {
	282	// Same annotations which was hovered, do nothing.
	283	return;
	284	} else {
	285	oldAnnotation.onMouseOut(e);
	286	}
	287	}
	288	if (fAnnotation != null) {
	289	fAnnotation.onMouseHover(e);
	290	}
	291	}
	292
	293	@Override
	294	public void mouseDoubleClick(MouseEvent e) {
	295	// Do nothing
	296	}
	297
	298	@Override
	299	public void mouseDown(MouseEvent e) {
	300	// Do nothing
	301	}
	302
	303	@Override
	304	public void mouseUp(MouseEvent e) {
	305	if (e.button != 1) {
	306	return;
	307	}
	308	if (fAction != null) {
	309	fAction.accept(e);
	310	}
	311	}
	312	}
	313
	314	/**
	315	* The source viewer
	316	*/
	317	private ISourceViewer fViewer;
	318
	319	/**
	320	* The annotation painter to use to draw the inlined annotations.
	321	*/
	322	private AnnotationPainter fPainter;
	323
	324	/**
	325	* Holds the current inlined annotations.
	326	*/
	327	private Set<AbstractInlinedAnnotation> fInlinedAnnotations;
	328
	329	/**
	330	* The mouse tracker used to support hover, click on inlined annotation.
	331	*/
	332	private final MouseTracker fMouseTracker= new MouseTracker();
	333
	334	/**
	335	* Install the inlined annotation support for the given viewer.
	336	*
	337	* @param viewer the source viewer
	338	* @param painter the annotation painter to use to draw the inlined annotations.
	339	*/
	340	public void install(ISourceViewer viewer, AnnotationPainter painter) {
	341	Assert.isNotNull(viewer);
	342	Assert.isNotNull(painter);
	343	fViewer= viewer;
	344	fPainter= painter;
	345	initPainter();
	346	StyledText text= fViewer.getTextWidget();
	347	if (text == null \|\| text.isDisposed()) {
	348	return;
	349	}
	350	if (fViewer instanceof ITextViewerExtension4) {
	351	updateStylesWidth= new UpdateStylesWidth();
	352	((ITextViewerExtension4) fViewer).addTextPresentationListener(updateStylesWidth);
	353	}
	354	visibleLines= new VisibleLines();
	355	text.addMouseListener(fMouseTracker);
	356	text.addMouseMoveListener(fMouseTracker);
	357	setColor(text.getDisplay().getSystemColor(SWT.COLOR_DARK_GRAY));
	358	}
	359
	360	/**
	361	* Initialize painter with inlined drawing strategy.
	362	*/
	363	private void initPainter() {
	364	fPainter.addDrawingStrategy(INLINED_STRATEGY_ID, INLINED_STRATEGY);
	365	fPainter.addAnnotationType(AbstractInlinedAnnotation.TYPE, INLINED_STRATEGY_ID);
	366	}
	367
	368	/**
	369	* Set the color to use to draw the inlined annotations.
	370	*
	371	* @param color the color to use to draw the inlined annotations.
	372	*/
	373	public void setColor(Color color) {
	374	fPainter.setAnnotationTypeColor(AbstractInlinedAnnotation.TYPE, color);
	375	}
	376
	377	/**
	378	* Unisntall the inlined annotation support
	379	*/
	380	public void uninstall() {
	381	StyledText text= this.fViewer.getTextWidget();
	382	if (text != null && !text.isDisposed()) {
	383	text.removeMouseListener(this.fMouseTracker);
	384	text.removeMouseMoveListener(this.fMouseTracker);
	385	}
	386	if (fViewer != null) {
	387	if (fViewer instanceof ITextViewerExtension4) {
	388	((ITextViewerExtension4) fViewer).removeTextPresentationListener(updateStylesWidth);
	389	}
	390	}
	391	if (visibleLines != null) {
	392	visibleLines.uninstall();
	393	visibleLines= null;
	394	}
	395	removeInlinedAnnotations();
	396	disposeFont();
	397	fViewer= null;
	398	fPainter= null;
	399	}
	400
	401	/**
	402	* Update the given inlined annotation.
	403	*
	404	* @param annotations the inlined annotation.
	405	*/
	406	public void updateAnnotations(Set<AbstractInlinedAnnotation> annotations) {
	407	IDocument document= fViewer != null ? fViewer.getDocument() : null;
	408	if (document == null) {
	409	// this case comes from when editor is closed before rendered is done.
	410	return;
	411	}
	412	IAnnotationModel annotationModel= fViewer.getAnnotationModel();
	413	if (annotationModel == null) {
	414	return;
	415	}
	416	Map<AbstractInlinedAnnotation, Position> annotationsToAdd= new HashMap<>();
	417	List<AbstractInlinedAnnotation> annotationsToRemove= fInlinedAnnotations != null
	418	? new ArrayList<>(fInlinedAnnotations)
	419	: Collections.emptyList();
	420	// Loop for annotations to update
	421	for (AbstractInlinedAnnotation ann : annotations) {
	422	if (!annotationsToRemove.remove(ann)) {
	423	// The annotation was not created, add it
	424	annotationsToAdd.put(ann, ann.getPosition());
	425	}
	426	}
	427	// Process annotations to remove
	428	for (AbstractInlinedAnnotation ann : annotationsToRemove) {
	429	// Mark annotation as deleted to ignore the draw
	430	ann.markDeleted(true);
	431	}
	432	// Update annotation model
	433	synchronized (getLockObject(annotationModel)) {
	434	// Update annotations with this inlined annotation support.
	435	for (AbstractInlinedAnnotation ann : annotations) {
	436	ann.setSupport(this);
	437	}
	438	if (annotationsToAdd.size() == 0 && annotationsToRemove.size() == 0) {
	439	// None change, do nothing. Here the user could change position of codemining
	440	// range
	441	// (ex: user key press
	442	// "Enter"), but we don't need to redraw the viewer because change of position
	443	// is done by AnnotationPainter.
	444	} else {
	445	if (annotationModel instanceof IAnnotationModelExtension) {
	446	((IAnnotationModelExtension) annotationModel).replaceAnnotations(
	447	annotationsToRemove.toArray(new Annotation[annotationsToRemove.size()]), annotationsToAdd);
	448	} else {
	449	removeInlinedAnnotations();
	450	Iterator<Entry<AbstractInlinedAnnotation, Position>> iter= annotationsToAdd.entrySet().iterator();
	451	while (iter.hasNext()) {
	452	Entry<AbstractInlinedAnnotation, Position> mapEntry= iter.next();
	453	annotationModel.addAnnotation(mapEntry.getKey(), mapEntry.getValue());
	454	}
	455	}
	456	}
	457	fInlinedAnnotations= annotations;
	458	}
	459	}
	460
	461	/**
	462	* Returns the existing codemining annotation with the given position information and null
	463	* otherwise.
	464	*
	465	* @param pos the position
	466	* @return the existing codemining annotation with the given position information and null
	467	* otherwise.
	468	*/
	469	@SuppressWarnings("unchecked")
	470	public <T extends AbstractInlinedAnnotation> T findExistingAnnotation(Position pos) {
	471	if (fInlinedAnnotations == null) {
	472	return null;
	473	}
	474	for (AbstractInlinedAnnotation ann : fInlinedAnnotations) {
	475	if (pos.equals(ann.getPosition()) && !ann.getPosition().isDeleted()) {
	476	try {
	477	return (T) ann;
	478	} catch (ClassCastException e) {
	479	// Do nothing
	480	}
	481	}
	482	}
	483	return null;
	484	}
	485
	486	/**
	487	* Returns the lock object for the given annotation model.
	488	*
	489	* @param annotationModel the annotation model
	490	* @return the annotation model's lock object
	491	*/
	492	private Object getLockObject(IAnnotationModel annotationModel) {
	493	if (annotationModel instanceof ISynchronizable) {
	494	Object lock= ((ISynchronizable) annotationModel).getLockObject();
	495	if (lock != null)
	496	return lock;
	497	}
	498	return annotationModel;
	499	}
	500
	501	/**
	502	* Remove the inlined annotations.
	503	*/
	504	private void removeInlinedAnnotations() {
	505
	506	IAnnotationModel annotationModel= fViewer.getAnnotationModel();
	507	if (annotationModel == null \|\| fInlinedAnnotations == null)
	508	return;
	509
	510	synchronized (getLockObject(annotationModel)) {
	511	if (annotationModel instanceof IAnnotationModelExtension) {
	512	((IAnnotationModelExtension) annotationModel).replaceAnnotations(
	513	fInlinedAnnotations.toArray(new Annotation[fInlinedAnnotations.size()]), null);
	514	} else {
	515	for (AbstractInlinedAnnotation annotation : fInlinedAnnotations)
	516	annotationModel.removeAnnotation(annotation);
	517	}
	518	fInlinedAnnotations= null;
	519	}
	520	}
	521
	522	/**
	523	* Returns the {@link AbstractInlinedAnnotation} from the given point and null otherwise.
	524	*
	525	* @param viewer the source viewer
	526	* @param x the x coordinate of the point
	527	* @param y the y coordinate of the point
	528	* @return the {@link AbstractInlinedAnnotation} from the given point and null otherwise.
	529	*/
	530	private AbstractInlinedAnnotation getInlinedAnnotationAtPoint(ISourceViewer viewer, int x, int y) {
	531	if (fInlinedAnnotations != null) {
	532	for (AbstractInlinedAnnotation ann : fInlinedAnnotations) {
	533	if (ann.contains(x, y) && isInVisibleLines(ann.getPosition().getOffset())) {
	534	return ann;
	535	}
	536	}
	537	}
	538	return null;
	539	}
	540
	541	/**
	542	* Execute UI {@link StyledText} function which requires UI Thread.
	543	*
	544	* @param text the styled text
	545	* @param fn the function to execute.
	546	*/
	547	static void runInUIThread(StyledText text, Consumer<StyledText> fn) {
	548	if (text == null \|\| text.isDisposed()) {
	549	return;
	550	}
	551	Display display= text.getDisplay();
	552	if (display.getThread() == Thread.currentThread()) {
	553	try {
	554	fn.accept(text);
	555	} catch (Exception e) {
	556	// Ignore UI error
	557	}
	558	} else {
	559	display.asyncExec(() -> {
	560	if (text.isDisposed()) {
	561	return;
	562	}
	563	try {
	564	fn.accept(text);
	565	} catch (Exception e) {
	566	// Ignore UI error
	567	}
	568	});
	569	}
	570	}
	571
	572	/**
	573	* Return whether the given offset is in visible lines.
	574	*
	575	* @param offset the offset
	576	* @return <code>true</code> if the given offset is in visible lines and <code>false</code>
	577	* otherwise.
	578	*/
	579	boolean isInVisibleLines(int offset) {
	580	if (visibleLines == null) {
	581	// case of support has been uninstalled and mining must be drawn.
	582	return false;
	583	}
	584	return visibleLines.isInVisibleLines(offset);
	585	}
	586
	587	/**
	588	* Returns the font according the specified <code>style</code> that the receiver will use to
	589	* paint textual information.
	590	*
	591	* @param style the style of Font widget to get.
	592	* @return the receiver's font according the specified <code>style</code>
	593	*
	594	*/
	595	Font getFont(int style) {
	596	StyledText styledText= fViewer != null ? fViewer.getTextWidget() : null;
	597	if (styledText == null) {
	598	return null;
	599	}
	600	if (!styledText.getFont().equals(regularFont)) {
	601	disposeFont();
	602	regularFont= styledText.getFont();
	603	}
	604	Device device= styledText.getDisplay();
	605	switch (style) {
	606	case SWT.BOLD:
	607	if (boldFont != null)
	608	return boldFont;
	609	return boldFont= new Font(device, getFontData(style));
	610	case SWT.ITALIC:
	611	if (italicFont != null)
	612	return italicFont;
	613	return italicFont= new Font(device, getFontData(style));
	614	case SWT.BOLD \| SWT.ITALIC:
	615	if (boldItalicFont != null)
	616	return boldItalicFont;
	617	return boldItalicFont= new Font(device, getFontData(style));
	618	default:
	619	return regularFont;
	620	}
	621	}
	622
	623	/**
	624	* Returns the font data array according the given style.
	625	*
	626	* @param style the style
	627	* @return the font data array according the given style.
	628	*/
	629	FontData[] getFontData(int style) {
	630	FontData[] fontDatas= regularFont.getFontData();
	631	for (int i= 0; i < fontDatas.length; i++) {
	632	fontDatas[i].setStyle(style);
	633	}
	634	return fontDatas;
	635	}
	636
	637	/**
	638	* Dispose the font.
	639	*/
	640	void disposeFont() {
	641	if (boldFont != null)
	642	boldFont.dispose();
	643	if (italicFont != null)
	644	italicFont.dispose();
	645	if (boldItalicFont != null)
	646	boldItalicFont.dispose();
	647	boldFont= italicFont= boldItalicFont= null;
	648	}
	649	}

+97

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/LineContentAnnotation.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide inline annotations support - Bug 527675
	9	*/
	10	package org.eclipse.jface.text.source.inlined;
	11
	12	import org.eclipse.swt.custom.StyledText;
	13	import org.eclipse.swt.graphics.Color;
	14	import org.eclipse.swt.graphics.GC;
	15
	16	import org.eclipse.jface.text.Position;
	17	import org.eclipse.jface.text.source.ISourceViewer;
	18
	19	/**
	20	* Inlined annotation which is drawn in the line content and which takes some place with a given
	21	* width.
	22	*
	23	* @since 3.13
	24	*/
	25	public class LineContentAnnotation extends AbstractInlinedAnnotation {
	26
	27	/**
	28	* The annotation width
	29	*/
	30	private int width;
	31
	32	private int redrawnCharacterWidth;
	33
	34	/**
	35	* Line content annotation constructor.
	36	*
	37	* @param position the position where the annotation must be drawn.
	38	* @param viewer the {@link ISourceViewer} where the annotation must be drawn.
	39	*/
	40	public LineContentAnnotation(Position position, ISourceViewer viewer) {
	41	super(position, viewer);
	42	}
	43
	44	/**
	45	* Returns the annotation width. By default it computes the well width for the text annotation.
	46	*
	47	* @return the annotation width.
	48	*/
	49	public final int getWidth() {
	50	return width;
	51	}
	52
	53	/**
	54	* {@inheritDoc}
	55	* <p>
	56	* After drawn, compute the text width and update it.
	57	* </p>
	58	*/
	59	@Override
	60	public final void draw(GC gc, StyledText textWidget, int offset, int length, Color color, int x, int y) {
	61	width= drawAndComputeWidth(gc, textWidget, offset, length, color, x, y);
	62	}
	63
	64	/**
	65	* Draw the inlined annotation. By default it draws the text of the annotation with gray color.
	66	* User can override this method to draw anything.
	67	*
	68	* @param gc the graphics context
	69	* @param textWidget the text widget to draw on
	70	* @param offset the offset of the line
	71	* @param length the length of the line
	72	* @param color the color of the line
	73	* @param x the x position of the annotation
	74	* @param y the y position of the annotation
	75	* @return the text width.
	76	*/
	77	protected int drawAndComputeWidth(GC gc, StyledText textWidget, int offset, int length, Color color, int x, int y) {
	78	// Draw the text annotation and returns the width
	79	super.draw(gc, textWidget, offset, length, color, x, y);
	80	return gc.stringExtent(getText()).x + 2 * gc.getFontMetrics().getAverageCharWidth();
	81	}
	82
	83	int getRedrawnCharacterWidth() {
	84	return redrawnCharacterWidth;
	85	}
	86
	87	void setRedrawnCharacterWidth(int redrawnCharacterWidth) {
	88	this.redrawnCharacterWidth= redrawnCharacterWidth;
	89	}
	90
	91	@Override
	92	boolean contains(int x, int y) {
	93	return (x >= this.fX && x <= this.fX + width && y >= this.fY && y <= this.fY + getTextWidget().getLineHeight());
	94	}
	95
	96	}

+69

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/LineHeaderAnnotation.java less more

	0	/**
	1	* Copyright (c) 2017, 2018 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide inline annotations support - Bug 527675
	9	*/
	10	package org.eclipse.jface.text.source.inlined;
	11
	12	import org.eclipse.swt.custom.StyledText;
	13
	14	import org.eclipse.jface.text.Position;
	15	import org.eclipse.jface.text.source.ISourceViewer;
	16
	17	/**
	18	* Inlined annotation which is drawn before a line and which takes some place with a given height.
	19	*
	20	* @since 3.13
	21	*/
	22	public class LineHeaderAnnotation extends AbstractInlinedAnnotation {
	23
	24	private int redrawnCharacterHeight;
	25
	26	private int redrawnCharacterWidth;
	27
	28	/**
	29	* Line header annotation constructor.
	30	*
	31	* @param position the position where the annotation must be drawn.
	32	* @param viewer the {@link ISourceViewer} where the annotation must be drawn.
	33	*/
	34	public LineHeaderAnnotation(Position position, ISourceViewer viewer) {
	35	super(position, viewer);
	36	}
	37
	38	/**
	39	* Returns the annotation height. By default, returns the {@link StyledText#getLineHeight()}.
	40	*
	41	* @return the annotation height.
	42	*/
	43	public int getHeight() {
	44	StyledText styledText= super.getTextWidget();
	45	return styledText.getLineHeight();
	46	}
	47
	48	int getRedrawnCharacterHeight() {
	49	return redrawnCharacterHeight;
	50	}
	51
	52	void setRedrawnCharacterHeight(int redrawnCharacterHeight) {
	53	this.redrawnCharacterHeight= redrawnCharacterHeight;
	54	}
	55
	56	int getRedrawnCharacterWidth() {
	57	return redrawnCharacterWidth;
	58	}
	59
	60	void setRedrawnCharacterWidth(int redrawnCharacterWidth) {
	61	this.redrawnCharacterWidth= redrawnCharacterWidth;
	62	}
	63
	64	@Override
	65	boolean contains(int x, int y) {
	66	return (x >= this.fX && y >= this.fY && y <= this.fY + getHeight());
	67	}
	68	}

+62

-0

org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/Positions.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide inline annotations support - Bug 527675
	9	*/
	10	package org.eclipse.jface.text.source.inlined;
	11
	12	import org.eclipse.jface.text.BadLocationException;
	13	import org.eclipse.jface.text.IDocument;
	14	import org.eclipse.jface.text.Position;
	15
	16	/**
	17	* Utilities class to retrieve position.
	18	*
	19	* @since 3.13
	20	*/
	21	public class Positions {
	22
	23	/**
	24	* Returns the line position by taking care or not of of leading spaces.
	25	*
	26	* @param lineIndex the line index
	27	* @param document the document
	28	* @param leadingSpaces true if line spacing must take care of and not otherwise.
	29	* @return the line position by taking care of leading spaces.
	30	* @throws BadLocationException if the line number is invalid in this document
	31	*/
	32	public static Position of(int lineIndex, IDocument document, boolean leadingSpaces) throws BadLocationException {
	33	int offset= document.getLineOffset(lineIndex);
	34	int lineLength= document.getLineLength(lineIndex);
	35	String line= document.get(offset, lineLength);
	36	if (leadingSpaces) {
	37	offset+= getLeadingSpaces(line);
	38	}
	39	return new Position(offset, 1);
	40	}
	41
	42	/**
	43	* Returns the leading spaces of the given line text.
	44	*
	45	* @param line the line text.
	46	* @return the leading spaces of the given line text.
	47	*/
	48	private static int getLeadingSpaces(String line) {
	49	int counter= 0;
	50	char[] chars= line.toCharArray();
	51	for (char c : chars) {
	52	if (c == '\t')
	53	counter++;
	54	else if (c == ' ')
	55	counter++;
	56	else
	57	break;
	58	}
	59	return counter;
	60	}
	61	}

+2

-2

org.eclipse.jface.text/src/org/eclipse/jface/text/templates/persistence/TemplateReaderWriter.java less more

197	197	boolean enabled = getBooleanValue(attributes, ENABLED_ATTRIBUTE, true);
198	198	boolean autoInsertable= getBooleanValue(attributes, AUTO_INSERTABLE_ATTRIBUTE, true);
199	199
200		StringBuffer buffer= new StringBuffer();
	200	StringBuilder buffer= new StringBuilder();
201	201	NodeList children= node.getChildNodes();
202	202	for (int j= 0; j != children.getLength(); j++) {
203	203	String value= children.item(j).getNodeValue();

385	385	if (idx == -1) {
386	386	return str;
387	387	}
388		StringBuffer buf= new StringBuffer();
	388	StringBuilder buf= new StringBuilder();
389	389	int k= 0;
390	390	while (idx != -1) {
391	391	buf.append(str.substring(k, idx));

+7

-0

org.eclipse.jface.text.examples/.classpath less more

	0	<?xml version="1.0" encoding="UTF-8"?>
	1	<classpath>
	2	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
	3	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
	4	<classpathentry kind="src" path="src"/>
	5	<classpathentry kind="output" path="bin"/>
	6	</classpath>

+2

-0

org.eclipse.jface.text.examples/.gitignore less more

	0	/bin/
	1	/target/⏎

+28

-0

org.eclipse.jface.text.examples/.project less more

	0	<?xml version="1.0" encoding="UTF-8"?>
	1	<projectDescription>
	2	<name>org.eclipse.jface.text.examples</name>
	3	<comment></comment>
	4	<projects>
	5	</projects>
	6	<buildSpec>
	7	<buildCommand>
	8	<name>org.eclipse.jdt.core.javabuilder</name>
	9	<arguments>
	10	</arguments>
	11	</buildCommand>
	12	<buildCommand>
	13	<name>org.eclipse.pde.ManifestBuilder</name>
	14	<arguments>
	15	</arguments>
	16	</buildCommand>
	17	<buildCommand>
	18	<name>org.eclipse.pde.SchemaBuilder</name>
	19	<arguments>
	20	</arguments>
	21	</buildCommand>
	22	</buildSpec>
	23	<natures>
	24	<nature>org.eclipse.pde.PluginNature</nature>
	25	<nature>org.eclipse.jdt.core.javanature</nature>
	26	</natures>
	27	</projectDescription>

+7

-0

org.eclipse.jface.text.examples/.settings/org.eclipse.jdt.core.prefs less more

	0	eclipse.preferences.version=1
	1	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
	2	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
	3	org.eclipse.jdt.core.compiler.compliance=1.8
	4	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
	5	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
	6	org.eclipse.jdt.core.compiler.source=1.8

+3

-0

org.eclipse.jface.text.examples/.settings/org.eclipse.pde.core.prefs less more

	0	eclipse.preferences.version=1
	1	pluginProject.extensions=false
	2	resolve.requirebundle=false

+11

-0

org.eclipse.jface.text.examples/META-INF/MANIFEST.MF less more

	0	Manifest-Version: 1.0
	1	Bundle-ManifestVersion: 2
	2	Bundle-Name: CodeMinig Examples
	3	Bundle-SymbolicName: org.eclipse.jface.text.examples
	4	Bundle-Version: 1.0.0.qualifier
	5	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
	6	Require-Bundle: org.eclipse.jface.text,
	7	org.eclipse.core.runtime,
	8	org.eclipse.swt,
	9	org.eclipse.jface;bundle-version="3.14.0"
	10	Automatic-Module-Name: org.eclipse.jface.text.examples

+4

-0

org.eclipse.jface.text.examples/build.properties less more

	0	source.. = src/
	1	output.. = bin/
	2	bin.includes = META-INF/,\
	3	.

+23

-0

org.eclipse.jface.text.examples/pom.xml less more

	0	<?xml version="1.0" encoding="UTF-8"?>
	1	<!--
	2	Copyright (c) 2012, 2014 Eclipse Foundation and others.
	3	All rights reserved. This program and the accompanying materials
	4	are made available under the terms of the Eclipse Distribution License v1.0
	5	which accompanies this distribution, and is available at
	6	http://www.eclipse.org/org/documents/edl-v10.php
	7
	8	Contributors:
	9	Igor Fedorenko - initial implementation
	10	-->
	11	<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	12	<modelVersion>4.0.0</modelVersion>
	13	<parent>
	14	<artifactId>eclipse.platform.text</artifactId>
	15	<groupId>eclipse.platform.text</groupId>
	16	<version>4.8.0-SNAPSHOT</version>
	17	</parent>
	18	<groupId>org.eclipse.core</groupId>
	19	<artifactId>org.eclipse.jface.text.examples</artifactId>
	20	<version>1.0.0-SNAPSHOT</version>
	21	<packaging>eclipse-plugin</packaging>
	22	</project>

+47

-0

org.eclipse.jface.text.examples/src/org/eclipse/jface/text/examples/codemining/AbstractClassCodeMining.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
	9	*/
	10	package org.eclipse.jface.text.examples.codemining;
	11
	12	import org.eclipse.jface.text.BadLocationException;
	13	import org.eclipse.jface.text.IDocument;
	14	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
	15	import org.eclipse.jface.text.codemining.LineHeaderCodeMining;
	16
	17	/**
	18	* Abstract class for class name mining.
	19	*
	20	*/
	21	public abstract class AbstractClassCodeMining extends LineHeaderCodeMining {
	22
	23	private final String className;
	24
	25	public AbstractClassCodeMining(String className, int afterLineNumber, IDocument document,
	26	ICodeMiningProvider resolver) throws BadLocationException {
	27	super(afterLineNumber, document, resolver);
	28	this.className = className;
	29	}
	30
	31	public String getClassName() {
	32	return className;
	33	}
	34
	35	public static String getLineText(IDocument document, int line) {
	36	try {
	37	int lo = document.getLineOffset(line);
	38	int ll = document.getLineLength(line);
	39	return document.get(lo, ll);
	40	} catch (Exception e) {
	41	e.printStackTrace();
	42	return null;
	43	}
	44	}
	45
	46	}

+49

-0

org.eclipse.jface.text.examples/src/org/eclipse/jface/text/examples/codemining/ClassImplementationCodeMining.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
	9	*/
	10	package org.eclipse.jface.text.examples.codemining;
	11
	12	import java.util.concurrent.CompletableFuture;
	13
	14	import org.eclipse.core.runtime.IProgressMonitor;
	15	import org.eclipse.jface.text.BadLocationException;
	16	import org.eclipse.jface.text.IDocument;
	17	import org.eclipse.jface.text.ITextViewer;
	18	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
	19
	20	/**
	21	* Class implementation mining.
	22	*
	23	*/
	24	public class ClassImplementationCodeMining extends AbstractClassCodeMining {
	25
	26	public ClassImplementationCodeMining(String className, int afterLineNumber, IDocument document,
	27	ICodeMiningProvider provider) throws BadLocationException {
	28	super(className, afterLineNumber, document, provider);
	29	}
	30
	31	@Override
	32	protected CompletableFuture<Void> doResolve(ITextViewer viewer, IProgressMonitor monitor) {
	33	return CompletableFuture.runAsync(() -> {
	34	IDocument document = viewer.getDocument();
	35	String className = super.getClassName();
	36	int refCount = 0;
	37	int lineCount = document.getNumberOfLines();
	38	for (int i = 0; i < lineCount; i++) {
	39	// check if request was canceled.
	40	monitor.isCanceled();
	41	String line = getLineText(document, i);
	42	refCount += line.contains("implements " + className) ? 1 : 0;
	43	}
	44	super.setLabel(refCount + " implementation");
	45	});
	46	}
	47
	48	}

+66

-0

org.eclipse.jface.text.examples/src/org/eclipse/jface/text/examples/codemining/ClassImplementationsCodeMiningProvider.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
	9	*/
	10	package org.eclipse.jface.text.examples.codemining;
	11
	12	import java.util.ArrayList;
	13	import java.util.List;
	14	import java.util.concurrent.CompletableFuture;
	15
	16	import org.eclipse.core.runtime.IProgressMonitor;
	17	import org.eclipse.jface.text.BadLocationException;
	18	import org.eclipse.jface.text.IDocument;
	19	import org.eclipse.jface.text.ITextViewer;
	20	import org.eclipse.jface.text.codemining.AbstractCodeMiningProvider;
	21	import org.eclipse.jface.text.codemining.ICodeMining;
	22
	23	/**
	24	* Class implementation mining provider.
	25	*
	26	*/
	27	public class ClassImplementationsCodeMiningProvider extends AbstractCodeMiningProvider {
	28
	29	@Override
	30	public CompletableFuture<List<? extends ICodeMining>> provideCodeMinings(ITextViewer viewer,
	31	IProgressMonitor monitor) {
	32	return CompletableFuture.supplyAsync(() -> {
	33	IDocument document = viewer.getDocument();
	34	List<ICodeMining> lenses = new ArrayList<>();
	35	int lineCount = document.getNumberOfLines();
	36	for (int i = 0; i < lineCount; i++) {
	37	// check if request was canceled.
	38	monitor.isCanceled();
	39	updateContentMining(i, document, "class ", lenses);
	40	updateContentMining(i, document, "interface ", lenses);
	41	}
	42	return lenses;
	43	});
	44	}
	45
	46	private void updateContentMining(int lineIndex, IDocument document, String token, List<ICodeMining> lenses) {
	47	String line = AbstractClassCodeMining.getLineText(document, lineIndex).trim();
	48	int index = line.indexOf(token);
	49	if (index == 0) {
	50	String className = line.substring(index + token.length(), line.length());
	51	index = className.indexOf(" ");
	52	if (index != -1) {
	53	className = className.substring(0, index);
	54	}
	55	if (className.length() > 0) {
	56	try {
	57	lenses.add(new ClassImplementationCodeMining(className, lineIndex, document, this));
	58	} catch (BadLocationException e) {
	59	e.printStackTrace();
	60	}
	61	}
	62	}
	63	}
	64
	65	}

+71

-0

org.eclipse.jface.text.examples/src/org/eclipse/jface/text/examples/codemining/ClassReferenceCodeMining.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
	9	*/
	10	package org.eclipse.jface.text.examples.codemining;
	11
	12	import java.util.concurrent.CancellationException;
	13	import java.util.concurrent.CompletableFuture;
	14
	15	import org.eclipse.core.runtime.IProgressMonitor;
	16	import org.eclipse.jface.text.BadLocationException;
	17	import org.eclipse.jface.text.IDocument;
	18	import org.eclipse.jface.text.ITextViewer;
	19	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
	20
	21	/**
	22	* Class reference mining.
	23	*
	24	*/
	25	public class ClassReferenceCodeMining extends AbstractClassCodeMining {
	26
	27	private Object lock = new Object();
	28
	29	public ClassReferenceCodeMining(String className, int afterLineNumber, IDocument document, ICodeMiningProvider provider)
	30	throws BadLocationException {
	31	super(className, afterLineNumber, document, provider);
	32	}
	33
	34	@Override
	35	protected CompletableFuture<Void> doResolve(ITextViewer viewer, IProgressMonitor monitor) {
	36	return CompletableFuture.runAsync(() -> {
	37	IDocument document = viewer.getDocument();
	38	String className = super.getClassName();
	39	try {
	40	int wait = Integer.parseInt(className);
	41	try {
	42	for (int i = 0; i < wait; i++) {
	43	monitor.isCanceled();
	44	synchronized (lock) {
	45	lock.wait(1000);
	46	}
	47	}
	48	} catch (InterruptedException e) {
	49	Thread.currentThread().interrupt();
	50	}
	51	} catch (NumberFormatException e) {
	52
	53	} catch (CancellationException e) {
	54	e.printStackTrace();
	55	throw e;
	56	}
	57
	58	int refCount = 0;
	59	int lineCount = document.getNumberOfLines();
	60	for (int i = 0; i < lineCount; i++) {
	61	// check if request was canceled.
	62	monitor.isCanceled();
	63	String line = getLineText(document, i);
	64	refCount += line.contains("new " + className) ? 1 : 0;
	65	}
	66	super.setLabel(refCount + " references");
	67	});
	68	}
	69
	70	}

+57

-0

org.eclipse.jface.text.examples/src/org/eclipse/jface/text/examples/codemining/ClassReferenceCodeMiningProvider.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
	9	*/
	10	package org.eclipse.jface.text.examples.codemining;
	11
	12	import java.util.ArrayList;
	13	import java.util.List;
	14	import java.util.concurrent.CompletableFuture;
	15
	16	import org.eclipse.core.runtime.IProgressMonitor;
	17	import org.eclipse.jface.text.BadLocationException;
	18	import org.eclipse.jface.text.IDocument;
	19	import org.eclipse.jface.text.ITextViewer;
	20	import org.eclipse.jface.text.codemining.AbstractCodeMiningProvider;
	21	import org.eclipse.jface.text.codemining.ICodeMining;
	22
	23	/**
	24	* Class reference mining provider.
	25	*
	26	*/
	27	public class ClassReferenceCodeMiningProvider extends AbstractCodeMiningProvider {
	28
	29	@Override
	30	public CompletableFuture<List<? extends ICodeMining>> provideCodeMinings(ITextViewer viewer,
	31	IProgressMonitor monitor) {
	32	return CompletableFuture.supplyAsync(() -> {
	33	IDocument document = viewer.getDocument();
	34	List<ICodeMining> lenses = new ArrayList<>();
	35	int lineCount = document.getNumberOfLines();
	36	for (int i = 0; i < lineCount; i++) {
	37	// check if request was canceled.
	38	monitor.isCanceled();
	39	String line = AbstractClassCodeMining.getLineText(document, i).trim();
	40	int index = line.indexOf("class ");
	41	if (index == 0) {
	42	String className = line.substring(index + "class ".length(), line.length()).trim();
	43	if (className.length() > 0) {
	44	try {
	45	lenses.add(new ClassReferenceCodeMining(className, i, document, this));
	46	} catch (BadLocationException e) {
	47	e.printStackTrace();
	48	}
	49	}
	50	}
	51	}
	52	return lenses;
	53	});
	54	}
	55
	56	}

+109

-0

org.eclipse.jface.text.examples/src/org/eclipse/jface/text/examples/codemining/CodeMiningDemo.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Add CodeMining support in SourceViewer - Bug 527515
	9	*/
	10	package org.eclipse.jface.text.examples.codemining;
	11
	12	import org.eclipse.jface.text.Document;
	13	import org.eclipse.jface.text.IDocument;
	14	import org.eclipse.jface.text.IRegion;
	15	import org.eclipse.jface.text.ITextViewerExtension2;
	16	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
	17	import org.eclipse.jface.text.reconciler.DirtyRegion;
	18	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	19	import org.eclipse.jface.text.reconciler.MonoReconciler;
	20	import org.eclipse.jface.text.source.Annotation;
	21	import org.eclipse.jface.text.source.AnnotationModel;
	22	import org.eclipse.jface.text.source.AnnotationPainter;
	23	import org.eclipse.jface.text.source.IAnnotationAccess;
	24	import org.eclipse.jface.text.source.ISourceViewer;
	25	import org.eclipse.jface.text.source.ISourceViewerExtension5;
	26	import org.eclipse.jface.text.source.SourceViewer;
	27	import org.eclipse.swt.SWT;
	28	import org.eclipse.swt.layout.FillLayout;
	29	import org.eclipse.swt.widgets.Display;
	30	import org.eclipse.swt.widgets.Shell;
	31
	32	/**
	33	* A Code Mining demo with class references and implementations minings.
	34	*
	35	*/
	36	public class CodeMiningDemo {
	37
	38	public static void main(String[] args) throws Exception {
	39
	40	Display display = new Display();
	41	Shell shell = new Shell(display);
	42	shell.setLayout(new FillLayout());
	43	shell.setText("Code Mining demo");
	44
	45	ISourceViewer sourceViewer = new SourceViewer(shell, null, SWT.V_SCROLL \| SWT.BORDER);
	46	sourceViewer.setDocument(
	47	new Document("// Type class & new keyword and see references CodeMining\n"
	48	+ "// Name class with a number N to emulate Nms before resolving the references CodeMining \n\n"
	49	+ "class A\n" + "new A\n" + "new A\n\n" + "class 5\n" + "new 5\n" + "new 5\n" + "new 5"),
	50	new AnnotationModel());
	51	// Add AnnotationPainter (required by CodeMining)
	52	addAnnotationPainter(sourceViewer);
	53	// Initialize codemining providers
	54	((ISourceViewerExtension5) sourceViewer).setCodeMiningProviders(new ICodeMiningProvider[] {
	55	new ClassReferenceCodeMiningProvider(), new ClassImplementationsCodeMiningProvider() });
	56	// Execute codemining in a reconciler
	57	MonoReconciler reconciler = new MonoReconciler(new IReconcilingStrategy() {
	58
	59	@Override
	60	public void setDocument(IDocument document) {
	61	((ISourceViewerExtension5) sourceViewer).updateCodeMinings();
	62	}
	63
	64	@Override
	65	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	66
	67	}
	68
	69	@Override
	70	public void reconcile(IRegion partition) {
	71	((ISourceViewerExtension5) sourceViewer).updateCodeMinings();
	72	}
	73	}, false);
	74	reconciler.install(sourceViewer);
	75
	76	shell.open();
	77	while (!shell.isDisposed()) {
	78	if (!display.readAndDispatch())
	79	display.sleep();
	80	}
	81	display.dispose();
	82	}
	83
	84	private static void addAnnotationPainter(ISourceViewer viewer) {
	85	IAnnotationAccess annotationAccess = new IAnnotationAccess() {
	86	@Override
	87	public Object getType(Annotation annotation) {
	88	return annotation.getType();
	89	}
	90
	91	@Override
	92	public boolean isMultiLine(Annotation annotation) {
	93	return true;
	94	}
	95
	96	@Override
	97	public boolean isTemporary(Annotation annotation) {
	98	return true;
	99	}
	100
	101	};
	102	AnnotationPainter painter = new AnnotationPainter(viewer, annotationAccess);
	103	((ITextViewerExtension2) viewer).addPainter(painter);
	104	// Register this annotation painter as CodeMining annotation painter.
	105	((ISourceViewerExtension5) viewer).setCodeMiningAnnotationPainter(painter);
	106	}
	107
	108	}

+127

-0

org.eclipse.jface.text.examples/src/org/eclipse/jface/text/examples/sources/inlined/ColorAnnotation.java less more

	0	/**s
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide inline annotations support - Bug 527675
	9	*/
	10	package org.eclipse.jface.text.examples.sources.inlined;
	11
	12	import java.util.function.Consumer;
	13
	14	import org.eclipse.jface.text.BadLocationException;
	15	import org.eclipse.jface.text.IDocument;
	16	import org.eclipse.jface.text.IRegion;
	17	import org.eclipse.jface.text.Position;
	18	import org.eclipse.jface.text.source.ISourceViewer;
	19	import org.eclipse.jface.text.source.inlined.LineContentAnnotation;
	20	import org.eclipse.jface.util.Geometry;
	21	import org.eclipse.swt.custom.StyledText;
	22	import org.eclipse.swt.events.MouseEvent;
	23	import org.eclipse.swt.graphics.Color;
	24	import org.eclipse.swt.graphics.FontMetrics;
	25	import org.eclipse.swt.graphics.GC;
	26	import org.eclipse.swt.graphics.RGB;
	27	import org.eclipse.swt.graphics.Rectangle;
	28	import org.eclipse.swt.widgets.ColorDialog;
	29	import org.eclipse.swt.widgets.Shell;
	30
	31	/**
	32	* Color annotation displays a colorized square before the rgb declaration.
	33	*/
	34	public class ColorAnnotation extends LineContentAnnotation {
	35
	36	private Color color;
	37
	38	private Consumer<MouseEvent> action = e -> {
	39	StyledText styledText = super.getTextWidget();
	40	Shell shell = new Shell(styledText.getDisplay());
	41	Rectangle location = Geometry.toDisplay(styledText, new Rectangle(e.x, e.y, 1, 1));
	42	shell.setLocation(location.x, location.y);
	43	// Open color dialog
	44	ColorDialog dialog = new ColorDialog(shell);
	45	// dialog.setRGB(annotation.getRGBA().rgb);
	46	RGB color = dialog.open();
	47	if (color != null) {
	48	// Color was selected, update the viewer
	49	try {
	50	int offset = getPosition().getOffset();
	51	IDocument document = getViewer().getDocument();
	52	IRegion line = document.getLineInformation(document.getLineOfOffset(offset));
	53	int length = line.getLength() - (offset - line.getOffset());
	54	String rgb = formatToRGB(color);
	55	document.replace(offset, length, rgb);
	56	} catch (BadLocationException e1) {
	57
	58	}
	59	}
	60	};
	61
	62	/**
	63	* Format the given rgb to hexa color.
	64	*
	65	* @param rgb
	66	* @return the hexa color from the given rgb.
	67	*/
	68	private static String formatToRGB(RGB rgb) {
	69	return new StringBuilder("rgb(").append(rgb.red).append(",").append(rgb.green).append(",").append(rgb.blue)
	70	.append(")").toString();
	71	}
	72
	73	public ColorAnnotation(Position pos, ISourceViewer viewer) {
	74	super(pos, viewer);
	75	}
	76
	77	public void setColor(Color color) {
	78	this.color = color;
	79	}
	80
	81	@Override
	82	protected int drawAndComputeWidth(GC gc, StyledText textWidget, int offset, int length, Color color, int x, int y) {
	83	FontMetrics fontMetrics = gc.getFontMetrics();
	84	int size = getSquareSize(fontMetrics);
	85	x += fontMetrics.getLeading();
	86	y += fontMetrics.getDescent();
	87
	88	Rectangle rect = new Rectangle(x, y, size, size);
	89
	90	// Fill square
	91	gc.setBackground(this.color);
	92	gc.fillRectangle(rect);
	93
	94	// Draw square box
	95	gc.setForeground(textWidget.getForeground());
	96	gc.drawRectangle(rect);
	97	return getSquareWidth(gc.getFontMetrics());
	98	}
	99
	100	/**
	101	* Returns the colorized square size.
	102	*
	103	* @param fontMetrics
	104	* @return the colorized square size.
	105	*/
	106	public static int getSquareSize(FontMetrics fontMetrics) {
	107	return fontMetrics.getHeight() - 2 * fontMetrics.getDescent();
	108	}
	109
	110	/**
	111	* Compute width of square
	112	*
	113	* @param styledText
	114	* @return the width of square
	115	*/
	116	private static int getSquareWidth(FontMetrics fontMetrics) {
	117	// width = 2 spaces + size width of square
	118	int width = 2 * fontMetrics.getAverageCharWidth() + getSquareSize(fontMetrics);
	119	return width;
	120	}
	121
	122	@Override
	123	public Consumer<MouseEvent> getAction(MouseEvent e) {
	124	return action;
	125	}
	126	}

+31

-0

org.eclipse.jface.text.examples/src/org/eclipse/jface/text/examples/sources/inlined/ColorStatusAnnotation.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide inline annotations support - Bug 527675
	9	*/
	10	package org.eclipse.jface.text.examples.sources.inlined;
	11
	12	import org.eclipse.jface.text.Position;
	13	import org.eclipse.jface.text.source.ISourceViewer;
	14	import org.eclipse.jface.text.source.inlined.LineHeaderAnnotation;
	15
	16	/**
	17	* Color status annotation shows the result of rgb parse before each line which
	18	* defines 'color:'.
	19	*/
	20	public class ColorStatusAnnotation extends LineHeaderAnnotation {
	21
	22	public ColorStatusAnnotation(Position position, ISourceViewer viewer) {
	23	super(position, viewer);
	24	}
	25
	26	public void setStatus(String status) {
	27	super.setText(status);
	28	}
	29
	30	}

+286

-0

org.eclipse.jface.text.examples/src/org/eclipse/jface/text/examples/sources/inlined/InlinedAnnotationDemo.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide inline annotations support - Bug 527675
	9	*/
	10	package org.eclipse.jface.text.examples.sources.inlined;
	11
	12	import java.util.HashSet;
	13	import java.util.Set;
	14	import java.util.regex.Matcher;
	15	import java.util.regex.Pattern;
	16
	17	import org.eclipse.jface.text.BadLocationException;
	18	import org.eclipse.jface.text.Document;
	19	import org.eclipse.jface.text.IDocument;
	20	import org.eclipse.jface.text.IRegion;
	21	import org.eclipse.jface.text.ITextViewerExtension2;
	22	import org.eclipse.jface.text.Position;
	23	import org.eclipse.jface.text.reconciler.DirtyRegion;
	24	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	25	import org.eclipse.jface.text.reconciler.MonoReconciler;
	26	import org.eclipse.jface.text.source.Annotation;
	27	import org.eclipse.jface.text.source.AnnotationModel;
	28	import org.eclipse.jface.text.source.AnnotationPainter;
	29	import org.eclipse.jface.text.source.IAnnotationAccess;
	30	import org.eclipse.jface.text.source.ISourceViewer;
	31	import org.eclipse.jface.text.source.SourceViewer;
	32	import org.eclipse.jface.text.source.inlined.AbstractInlinedAnnotation;
	33	import org.eclipse.jface.text.source.inlined.InlinedAnnotationSupport;
	34	import org.eclipse.jface.text.source.inlined.LineContentAnnotation;
	35	import org.eclipse.jface.text.source.inlined.LineHeaderAnnotation;
	36	import org.eclipse.jface.text.source.inlined.Positions;
	37	import org.eclipse.swt.SWT;
	38	import org.eclipse.swt.graphics.Color;
	39	import org.eclipse.swt.graphics.Device;
	40	import org.eclipse.swt.layout.FillLayout;
	41	import org.eclipse.swt.widgets.Display;
	42	import org.eclipse.swt.widgets.Shell;
	43
	44	/**
	45	* An inlined demo with {@link LineHeaderAnnotation} and
	46	* {@link LineContentAnnotation} annotations both:
	47	*
	48	* <ul>
	49	* <li>a status OK, NOK is displayed before the line which starts with 'color:'.
	50	* This status is the result of the content after 'color' which must be a rgb
	51	* content. Here {@link ColorStatusAnnotation} is used.</li>
	52	* <li>a colorized square is displayed before the rgb declaration (inside the
	53	* line content). Here {@link ColorAnnotation} is used.</li>
	54	* </ul>
	55	*
	56	*/
	57	public class InlinedAnnotationDemo {
	58
	59	public static void main(String[] args) throws Exception {
	60
	61	Display display = new Display();
	62	Shell shell = new Shell(display);
	63	shell.setLayout(new FillLayout());
	64	shell.setText("Inlined annotation demo");
	65
	66	// Create source viewer and initialize the content
	67	ISourceViewer sourceViewer = new SourceViewer(shell, null, SWT.V_SCROLL \| SWT.BORDER);
	68	sourceViewer.setDocument(new Document("\ncolor:rgb(255, 255, 0)"), new AnnotationModel());
	69
	70	// Initialize inlined annotations support
	71	InlinedAnnotationSupport support = new InlinedAnnotationSupport();
	72	support.install(sourceViewer, createAnnotationPainter(sourceViewer));
	73
	74	// Refresh inlined annotation in none UI Thread with reconciler.
	75	MonoReconciler reconciler = new MonoReconciler(new IReconcilingStrategy() {
	76
	77	@Override
	78	public void setDocument(IDocument document) {
	79	Set<AbstractInlinedAnnotation> annotations = getInlinedAnnotation(sourceViewer, support);
	80	support.updateAnnotations(annotations);
	81	}
	82
	83	@Override
	84	public void reconcile(IRegion partition) {
	85	Set<AbstractInlinedAnnotation> anns = getInlinedAnnotation(sourceViewer, support);
	86	support.updateAnnotations(anns);
	87	}
	88
	89	@Override
	90	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	91
	92	}
	93	}, false);
	94	reconciler.setDelay(1);
	95	reconciler.install(sourceViewer);
	96
	97	shell.open();
	98	while (!shell.isDisposed()) {
	99	if (!display.readAndDispatch())
	100	display.sleep();
	101	}
	102	display.dispose();
	103	}
	104
	105	/**
	106	* Create annotation painter.
	107	*
	108	* @param viewer
	109	* the viewer.
	110	* @return annotation painter.
	111	*/
	112	private static AnnotationPainter createAnnotationPainter(ISourceViewer viewer) {
	113	IAnnotationAccess annotationAccess = new IAnnotationAccess() {
	114	@Override
	115	public Object getType(Annotation annotation) {
	116	return annotation.getType();
	117	}
	118
	119	@Override
	120	public boolean isMultiLine(Annotation annotation) {
	121	return true;
	122	}
	123
	124	@Override
	125	public boolean isTemporary(Annotation annotation) {
	126	return true;
	127	}
	128
	129	};
	130	AnnotationPainter painter = new AnnotationPainter(viewer, annotationAccess);
	131	((ITextViewerExtension2) viewer).addPainter(painter);
	132	return painter;
	133	}
	134
	135	/**
	136	* Returns the inlined annotations list to display in the given viewer.
	137	*
	138	* @param viewer
	139	* the viewer
	140	* @param support
	141	* the inlined annotation suppor.
	142	* @return the inlined annotations list to display in the given viewer.
	143	*/
	144	private static Set<AbstractInlinedAnnotation> getInlinedAnnotation(ISourceViewer viewer,
	145	InlinedAnnotationSupport support) {
	146	IDocument document = viewer.getDocument();
	147	Set<AbstractInlinedAnnotation> annotations = new HashSet<>();
	148	int lineCount = document.getNumberOfLines();
	149	for (int i = 0; i < lineCount; i++) {
	150	String line = getLineText(document, i).trim();
	151	int index = line.indexOf("color:");
	152	if (index == 0) {
	153	String rgb = line.substring(index + "color:".length(), line.length()).trim();
	154	try {
	155	String status = "OK!";
	156	Color color = parse(rgb, viewer.getTextWidget().getDisplay());
	157	if (color != null) {
	158	} else {
	159	status = "ERROR!";
	160	}
	161	// Status color annotation
	162	Position pos = Positions.of(i, document, true);
	163	ColorStatusAnnotation statusAnnotation = support.findExistingAnnotation(pos);
	164	if (statusAnnotation == null) {
	165	statusAnnotation = new ColorStatusAnnotation(pos, viewer);
	166	}
	167	statusAnnotation.setStatus(status);
	168	annotations.add(statusAnnotation);
	169
	170	// Color annotation
	171	if (color != null) {
	172	Position colorPos = new Position(pos.offset + index + "color:".length(), 1);
	173	ColorAnnotation colorAnnotation = support.findExistingAnnotation(colorPos);
	174	if (colorAnnotation == null) {
	175	colorAnnotation = new ColorAnnotation(colorPos, viewer);
	176	}
	177	colorAnnotation.setColor(color);
	178	annotations.add(colorAnnotation);
	179	}
	180
	181	// rgb parameter names annotations
	182	int rgbIndex = line.indexOf("rgb");
	183	if (rgbIndex != -1) {
	184	rgbIndex = rgbIndex + "rgb".length();
	185	int startOffset = pos.offset + rgbIndex;
	186	String rgbContent = line.substring(rgbIndex, line.length());
	187	int startIndex = addRGBParamNameAnnotation("red:", rgbContent, 0, startOffset, viewer, support,
	188	annotations);
	189	if (startIndex != -1) {
	190	startIndex = addRGBParamNameAnnotation("green:", rgbContent, startIndex, startOffset, viewer,
	191	support, annotations);
	192	if (startIndex != -1) {
	193	startIndex = addRGBParamNameAnnotation("blue:", rgbContent, startIndex, startOffset,
	194	viewer, support, annotations);
	195	}
	196	}
	197	}
	198
	199	} catch (BadLocationException e) {
	200	e.printStackTrace();
	201	}
	202	}
	203	}
	204	return annotations;
	205	}
	206
	207	/**
	208	* Add RGB parameter name annotation
	209	*
	210	* @param paramName
	211	* @param rgbContent
	212	* @param startIndex
	213	* @param startOffset
	214	* @param viewer
	215	* @param support
	216	* @param annotations
	217	* @return the current parsed index
	218	*/
	219	private static int addRGBParamNameAnnotation(String paramName, String rgbContent, int startIndex, int startOffset,
	220	ISourceViewer viewer, InlinedAnnotationSupport support, Set<AbstractInlinedAnnotation> annotations) {
	221	char startChar = startIndex == 0 ? '(' : ',';
	222	char[] chars = rgbContent.toCharArray();
	223	for (int i = startIndex; i < chars.length; i++) {
	224	char c = chars[i];
	225	if (c == startChar) {
	226	if (i == chars.length - 1) {
	227	return -1;
	228	}
	229	Position paramPos = new Position(startOffset + i + 1, 1);
	230	LineContentAnnotation colorParamAnnotation = support.findExistingAnnotation(paramPos);
	231	if (colorParamAnnotation == null) {
	232	colorParamAnnotation = new LineContentAnnotation(paramPos, viewer);
	233	}
	234	colorParamAnnotation.setText(paramName);
	235	annotations.add(colorParamAnnotation);
	236	return i + 1;
	237	}
	238	}
	239	return -1;
	240	}
	241
	242	/**
	243	* Parse the given input rgb color and returns an instance of SWT Color and null
	244	* otherwise.
	245	*
	246	* @param input
	247	* the rgb string color
	248	* @param device
	249	* @return the created color and null otherwise.
	250	*/
	251	private static Color parse(String input, Device device) {
	252	Pattern c = Pattern.compile("rgb \$ ([0-9]+), ([0-9]+), ([0-9]+) *\$");
	253	Matcher m = c.matcher(input);
	254	if (m.matches()) {
	255	try {
	256	return new Color(device, Integer.valueOf(m.group(1)), // r
	257	Integer.valueOf(m.group(2)), // g
	258	Integer.valueOf(m.group(3))); // b
	259	} catch (Exception e) {
	260
	261	}
	262	}
	263	return null;
	264	}
	265
	266	/**
	267	* Returns the line text.
	268	*
	269	* @param document
	270	* the document.
	271	* @param line
	272	* the line index.
	273	* @return the line text.
	274	*/
	275	private static String getLineText(IDocument document, int line) {
	276	try {
	277	int offset = document.getLineOffset(line);
	278	int length = document.getLineLength(line);
	279	return document.get(offset, length);
	280	} catch (Exception e) {
	281	e.printStackTrace();
	282	return null;
	283	}
	284	}
	285	}

+2

-1

org.eclipse.jface.text.tests/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %Plugin.name
3	3	Bundle-SymbolicName: org.eclipse.jface.text.tests
4		Bundle-Version: 3.11.100.qualifier
	4	Bundle-Version: 3.11.200.qualifier
5	5	Bundle-Vendor: %Plugin.providerName
6	6	Bundle-Localization: plugin
7	7	Export-Package:

18	18	org.eclipse.core.runtime;bundle-version="[3.5.0,4.0.0)"
19	19	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
20	20	Eclipse-BundleShape: dir
	21	Automatic-Module-Name: org.eclipse.jface.text.tests

+2

-0

org.eclipse.jface.text.tests/forceQualifierUpdate.txt less more

	0	# To force a version qualifier update add the bug here
	1	Pick up new signing certificate

+2

-2

org.eclipse.jface.text.tests/pom.xml less more

13	13	<parent>
14	14	<artifactId>tests-pom</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	<relativePath>../tests-pom/</relativePath>
18	18	</parent>
19	19	<groupId>org.eclipse.jface</groupId>
20	20	<artifactId>org.eclipse.jface.text.tests</artifactId>
21		<version>3.11.100-SNAPSHOT</version>
	21	<version>3.11.200-SNAPSHOT</version>
22	22	<packaging>eclipse-test-plugin</packaging>
23	23	<properties>
24	24	<testSuite>${project.artifactId}</testSuite>

+2

-1

org.eclipse.search/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %pluginName
3	3	Bundle-SymbolicName: org.eclipse.search; singleton:=true
4		Bundle-Version: 3.11.100.qualifier
	4	Bundle-Version: 3.11.200.qualifier
5	5	Bundle-Activator: org.eclipse.search.internal.ui.SearchPlugin
6	6	Bundle-ActivationPolicy: lazy
7	7	Bundle-Vendor: %providerName

32	32	org.eclipse.ltk.ui.refactoring;bundle-version="[3.5.0,4.0.0)"
33	33	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
34	34	Import-Package: com.ibm.icu.text
	35	Automatic-Module-Name: org.eclipse.search

+0

-58

~~org.eclipse.search/apichanges_search.html~~ less more

0		<!DOCTYPE doctype PUBLIC "-//w3c//dtd html 4.0 transitional//en">
1		<html>
2		<head>
3		<meta http-equiv="Content-Type"
4		content="text/html; charset=iso-8859-1">
5		<meta name="Author" content="IBM">
6		<title>Search Breaking API changes</title>
7		<link rel="stylesheet" href="http://dev.eclipse.org/default_style.css"
8		type="text/css">
9		</head>
10		<body style="color: rgb(0, 0, 0); background-color: rgb(255, 255, 255);">
11		<font color="#8080ff" size="-2">platform search</font>
12		<p>This document lists the breaking API changes that occurred between
13		R3.3 and R3.4 and
14		how to migrate from the R3.3 API to the R3.4 API.
15		</p>
16		<table border="0" cellpadding="2" cellspacing="5" width="100%" summary="Breaking API changes from R3.3 to R3.4">
17		<tbody>
18		<tr>
19		<td align="left" width="72%"> <font size="+3"><b>search -
20		Breaking API changes from R3.3 to R3.4</b></font> <br>
21		</td>
22		</tr>
23		<tr>
24		<td>
25		None
26		</td>
27		</tr>
28		</tbody>
29		</table>
30		<p> </p>
31		<table border="0" cellpadding="2" cellspacing="5" width="100%" summary="Non-breaking API changes from R3.3 to R3.4">
32		<tbody>
33		<tr>
34		<td align="left" width="72%"> <font size="+3"><b>search -
35		Non-breaking API changes from R3.3 to R3.4</b></font> <br>
36		</td>
37		</tr>
38		<tr>
39		<td>New API added to AbstractTextSearchViewPage
40		<ul>
41		<li>evaluateChangedElements(Match[], Collection) - controls which elements are later sent to <code>elementsChanged</code></li>
42		</ul> </td>
43		</tr>
44		<tr><td><hr></td></tr>
45		<tr>
46		<td>New attribute for extension point <code>org.eclipse.search.searchResultViewPages</code>:
47		<ul>
48		<li>helpContextId - Help context id for the search result page</li>
49		</ul> </td>
50		</tr>
51		</tbody>
52		</table>
53		<p>
54		API changes from 3.2 to 3.3 can be found <a href="./notes/r3.3/apichanges_search.html?view=co">here</a>.
55		</p>
56		</body>
57		</html>

+1

-2

org.eclipse.search/new search/org/eclipse/search/ui/actions/TextSearchGroup.java less more

75	75	private void createActions(IEditorPart editor) {
76	76	fActions= new FindInRecentScopeActionDelegate[] {
77	77	new FindInWorkspaceActionDelegate(), new FindInProjectActionDelegate(), new FindInFileActionDelegate(), new FindInWorkingSetActionDelegate()};
78		for (int i= 0; i < fActions.length; i++) {
79		FindInRecentScopeActionDelegate action= fActions[i];
	78	for (FindInRecentScopeActionDelegate action : fActions) {
80	79	action.setActiveEditor(action, editor);
81	80	}
82	81	}

+16

-16

org.eclipse.search/new search/org/eclipse/search/ui/text/AbstractTextSearchResult.java less more

95	95	public void addMatches(Match[] matches) {
96	96	Collection<Match> reallyAdded= new ArrayList<>();
97	97	synchronized (fElementsToMatches) {
98		for (int i = 0; i < matches.length; i++) {
99		if (doAddMatch(matches[i]))
100		reallyAdded.add(matches[i]);
	98	for (Match match : matches) {
	99	if (doAddMatch(match))
	100	reallyAdded.add(match);
101	101	}
102	102	}
103	103	if (!reallyAdded.isEmpty())

141	141
142	142	private static int getInsertIndex(List<Match> matches, Match match) {
143	143	int count= matches.size();
144		int min = 0, max = count - 1;
	144	int min = 0;
	145	int max = count - 1;
145	146	while (min <= max) {
146	147	int mid = (min + max) / 2;
147	148	Match data = matches.get(mid);

207	208	public void removeMatches(Match[] matches) {
208	209	Collection<Match> existing= new ArrayList<>();
209	210	synchronized (fElementsToMatches) {
210		for (int i = 0; i < matches.length; i++) {
211		if (doRemoveMatch(matches[i]))
212		existing.add(matches[i]); // no duplicate matches at this point
	211	for (Match match : matches) {
	212	if (doRemoveMatch(match))
	213	existing.add(match); // no duplicate matches at this point
213	214	}
214	215	}
215	216	if (!existing.isEmpty())

265	266	boolean disableFiltering= getActiveMatchFilters() == null;
266	267	ArrayList<Match> changed= new ArrayList<>();
267	268	Object[] elements= getElements();
268		for (int i= 0; i < elements.length; i++) {
269		Match[] matches= getMatches(elements[i]);
270		for (int k= 0; k < matches.length; k++) {
271		if (disableFiltering \|\| updateFilterState(matches[k])) {
272		changed.add(matches[k]);
	269	for (Object element : elements) {
	270	Match[] matches= getMatches(element);
	271	for (Match match : matches) {
	272	if (disableFiltering \|\| updateFilterState(match)) {
	273	changed.add(match);
273	274	}
274	275	}
275	276	}

287	288	}
288	289
289	290	boolean oldState= match.isFiltered();
290		for (int i= 0; i < matchFilters.length; i++) {
291		if (matchFilters[i].filters(match)) {
	291	for (MatchFilter matchFilter : matchFilters) {
	292	if (matchFilter.filters(match)) {
292	293	match.setFiltered(true);
293	294	return !oldState;
294	295	}

306	307	public int getMatchCount() {
307	308	int count= 0;
308	309	synchronized (fElementsToMatches) {
309		for (Iterator<List<Match>> elements= fElementsToMatches.values().iterator(); elements.hasNext();) {
310		List<Match> element= elements.next();
	310	for (List<Match> element : fElementsToMatches.values()) {
311	311	if (element != null)
312	312	count+= element.size();
313	313	}

+19

-22

org.eclipse.search/new search/org/eclipse/search/ui/text/AbstractTextSearchViewPage.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2016 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

12	12
13	13	import java.util.ArrayList;
14	14	import java.util.HashSet;
15		import java.util.Iterator;
16	15	import java.util.Set;
17	16
18	17	import org.eclipse.swt.SWT;

200	199	public void selectionChanged(SelectionChangedEvent event) {
201	200	// forward to my listeners
202	201	SelectionChangedEvent wrappedEvent= new SelectionChangedEvent(this, event.getSelection());
203		for (Iterator<ISelectionChangedListener> listeners= fListeners.iterator(); listeners.hasNext();) {
204		ISelectionChangedListener listener= listeners.next();
	202	for (ISelectionChangedListener listener : fListeners) {
205	203	listener.selectionChanged(wrappedEvent);
206	204	}
207	205	}

854	852	IMenuManager menu= bars.getMenuManager();
855	853
856	854	if (filterActions != null) {
857		for (int i= 0; i < filterActions.length; i++) {
858		menu.remove(filterActions[i].getId());
	855	for (IAction filterAction : filterActions) {
	856	menu.remove(filterAction.getId());
859	857	}
860	858	}
861	859	menu.remove(MatchFilterSelectionAction.ACTION_ID);

891	889
892	890	private void updateFilterActions(IAction[] filterActions) {
893	891	if (filterActions != null) {
894		for (int i= 0; i < filterActions.length; i++) {
895		IAction curr= filterActions[i];
	892	for (IAction curr : filterActions) {
896	893	if (curr instanceof IUpdate) {
897	894	((IUpdate) curr).update();
898	895	}

1123	1120	}
1124	1121
1125	1122	private Object getFirstSelectedElement() {
1126		IStructuredSelection selection = (IStructuredSelection) fViewer.getSelection();
	1123	IStructuredSelection selection = fViewer.getStructuredSelection();
1127	1124	if (selection.size() > 0)
1128	1125	return selection.getFirstElement();
1129	1126	return null;

1237	1234	* @since 3.4
1238	1235	*/
1239	1236	protected void evaluateChangedElements(Match[] matches, Set<Object> changedElements) {
1240		for (int i = 0; i < matches.length; i++) {
1241		changedElements.add(matches[i].getElement());
	1237	for (Match match : matches) {
	1238	changedElements.add(match.getElement());
1242	1239	}
1243	1240	}
1244	1241

1351	1348	if (result == null)
1352	1349	return;
1353	1350	StructuredViewer viewer = getViewer();
1354		IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
	1351	IStructuredSelection selection = viewer.getStructuredSelection();
1355	1352
1356	1353	HashSet<Match> set = new HashSet<>();
1357	1354	if (viewer instanceof TreeViewer) {

1368	1365	}
1369	1366
1370	1367	private void collectAllMatches(HashSet<Match> set, Object[] elements) {
1371		for (int j = 0; j < elements.length; j++) {
1372		Match[] matches = getDisplayedMatches(elements[j]);
1373		for (int i = 0; i < matches.length; i++) {
1374		set.add(matches[i]);
	1368	for (Object element : elements) {
	1369	Match[] matches = getDisplayedMatches(element);
	1370	for (Match match : matches) {
	1371	set.add(match);
1375	1372	}
1376	1373	}
1377	1374	}
1378	1375
1379	1376	private void collectAllMatchesBelow(AbstractTextSearchResult result, Set<Match> set, ITreeContentProvider cp, Object[] elements) {
1380		for (int j = 0; j < elements.length; j++) {
1381		Match[] matches = getDisplayedMatches(elements[j]);
1382		for (int i = 0; i < matches.length; i++) {
1383		set.add(matches[i]);
1384		}
1385		Object[] children = cp.getChildren(elements[j]);
	1377	for (Object element : elements) {
	1378	Match[] matches = getDisplayedMatches(element);
	1379	for (Match match : matches) {
	1380	set.add(match);
	1381	}
	1382	Object[] children = cp.getChildren(element);
1386	1383	collectAllMatchesBelow(result, set, cp, children);
1387	1384	}
1388	1385	}

+5

-7

org.eclipse.search/new search/org/eclipse/search/ui/text/FileTextSearchScope.java less more

189	189	return BasicElementLabels.getFilePattern("*"); //$NON-NLS-1$
190	190	}
191	191	Arrays.sort(ext);
192		StringBuffer buf= new StringBuffer();
	192	StringBuilder buf= new StringBuilder();
193	193	for (int i= 0; i < ext.length; i++) {
194	194	if (i > 0) {
195	195	buf.append(", "); //$NON-NLS-1$

261	261
262	262	private static IResource[] removeRedundantEntries(IResource[] elements, boolean includeDerived) {
263	263	ArrayList<IResource> res= new ArrayList<>();
264		for (int i= 0; i < elements.length; i++) {
265		IResource curr= elements[i];
	264	for (IResource curr : elements) {
266	265	addToList(res, curr, includeDerived);
267	266	}
268	267	return res.toArray(new IResource[res.size()]);

270	269
271	270	private static IResource[] convertToResources(IWorkingSet[] workingSets, boolean includeDerived) {
272	271	ArrayList<IResource> res= new ArrayList<>();
273		for (int i= 0; i < workingSets.length; i++) {
274		IWorkingSet workingSet= workingSets[i];
	272	for (IWorkingSet workingSet : workingSets) {
275	273	if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
276	274	return new IResource[] { ResourcesPlugin.getWorkspace().getRoot() };
277	275	}
278	276	IAdaptable[] elements= workingSet.getElements();
279		for (int k= 0; k < elements.length; k++) {
280		IResource curr= elements[k].getAdapter(IResource.class);
	277	for (IAdaptable element : elements) {
	278	IResource curr= element.getAdapter(IResource.class);
281	279	if (curr != null) {
282	280	addToList(res, curr, includeDerived);
283	281	}

+2

-4

org.eclipse.search/new search/org/eclipse/search2/internal/ui/InternalSearchUI.java less more

320	320	int numberQueriesNotShown= 0;
321	321	SearchViewManager searchViewManager= getSearchViewManager();
322	322	ISearchQuery[] queries= searchManager.getQueries();
323		for (int i= 0; i < queries.length; i++) {
324		ISearchQuery query= queries[i];
	323	for (ISearchQuery query : queries) {
325	324	if (!searchViewManager.isShown(query)) {
326	325	if (++numberQueriesNotShown >= historyLimit) {
327	326	removeQuery(query);

331	330	}
332	331
333	332	public void removeAllQueries() {
334		for (Iterator<ISearchQuery> queries= fSearchJobs.keySet().iterator(); queries.hasNext();) {
335		ISearchQuery query= queries.next();
	333	for (ISearchQuery query : fSearchJobs.keySet()) {
336	334	cancelSearch(query);
337	335	}
338	336	fSearchJobs.clear();

+2

-2

org.eclipse.search/new search/org/eclipse/search2/internal/ui/MatchFilterAction.java less more

66	66	AbstractTextSearchResult input= fPage.getInput();
67	67	if (input != null) {
68	68	MatchFilter[] activeMatchFilters= input.getActiveMatchFilters();
69		for (int i= 0; i < activeMatchFilters.length; i++) {
70		if (fFilter.equals(activeMatchFilters[i])) {
	69	for (MatchFilter activeMatchFilter : activeMatchFilters) {
	70	if (fFilter.equals(activeMatchFilter)) {
71	71	return true;
72	72	}
73	73	}

+2

-3

org.eclipse.search/new search/org/eclipse/search2/internal/ui/MatchFilterSelectionDialog.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2008 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

34	34	import org.eclipse.jface.viewers.CheckboxTableViewer;
35	35	import org.eclipse.jface.viewers.ICheckStateListener;
36	36	import org.eclipse.jface.viewers.ISelectionChangedListener;
37		import org.eclipse.jface.viewers.IStructuredSelection;
38	37	import org.eclipse.jface.viewers.LabelProvider;
39	38	import org.eclipse.jface.viewers.SelectionChangedEvent;
40	39

229	228	}
230	229
231	230	private void performFilterListSelectionChanged() {
232		Object selectedElement = ((IStructuredSelection) fListViewer.getSelection()).getFirstElement();
	231	Object selectedElement = fListViewer.getStructuredSelection().getFirstElement();
233	232	if (selectedElement != null)
234	233	fDescription.setText(((MatchFilter) selectedElement).getDescription());
235	234	else

+5

-5

org.eclipse.search/new search/org/eclipse/search2/internal/ui/SearchHistoryDropDownAction.java less more

47	47	}
48	48
49	49	private String escapeAmp(String label) {
50		StringBuffer buf= new StringBuffer();
	50	StringBuilder buf= new StringBuilder();
51	51	for (int i= 0; i < label.length(); i++) {
52	52	char ch= label.charAt(i);
53	53	buf.append(ch);

116	116
117	117	ISearchQuery[] searches= NewSearchUI.getQueries();
118	118	if (searches.length > 0) {
119		for (int i= 0; i < searches.length; i++) {
120		ISearchResult search= searches[i].getSearchResult();
121		ShowSearchFromHistoryAction action= new ShowSearchFromHistoryAction(search);
122		action.setChecked(search.equals(currentSearch));
	119	for (ISearchQuery search : searches) {
	120	ISearchResult searchResult= search.getSearchResult();
	121	ShowSearchFromHistoryAction action= new ShowSearchFromHistoryAction(searchResult);
	122	action.setChecked(searchResult.equals(currentSearch));
123	123	addActionToMenu(fMenu, action);
124	124	}
125	125	new MenuItem(fMenu, SWT.SEPARATOR);

+5

-6

org.eclipse.search/new search/org/eclipse/search2/internal/ui/SearchHistorySelectionDialog.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2016 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

364	364	}
365	365
366	366	protected final void validateDialogState() {
367		IStructuredSelection sel= (IStructuredSelection) fViewer.getSelection();
	367	IStructuredSelection sel = fViewer.getStructuredSelection();
368	368	int elementsSelected= sel.toList().size();
369	369
370	370	fRemoveButton.setEnabled(elementsSelected > 0);

389	389	@Override
390	390	protected void buttonPressed(int buttonId) {
391	391	if (buttonId == REMOVE_ID) {
392		IStructuredSelection selection= (IStructuredSelection) fViewer.getSelection();
	392	IStructuredSelection selection = fViewer.getStructuredSelection();
393	393	Iterator<?> searchResults= selection.iterator();
394	394	while (searchResults.hasNext()) {
395	395	ISearchResult curr= (ISearchResult) searchResults.next();

417	417	// Build a list of selected children.
418	418	ISelection selection= fViewer.getSelection();
419	419	if (selection instanceof IStructuredSelection)
420		setResult(((IStructuredSelection) fViewer.getSelection()).toList());
	420	setResult(fViewer.getStructuredSelection().toList());
421	421
422	422	// remove queries
423		for (Iterator<ISearchResult> iter= fRemovedEntries.iterator(); iter.hasNext();) {
424		ISearchResult result= iter.next();
	423	for (ISearchResult result : fRemovedEntries) {
425	424	ISearchQuery query= result.getQuery();
426	425	if (query != null) { // must not be null: invalid implementation of a search query
427	426	InternalSearchUI.getInstance().removeQuery(query);

+5

-6

org.eclipse.search/new search/org/eclipse/search2/internal/ui/SearchPageRegistry.java less more

42	42	fExtensionToInstance= new HashMap<>();
43	43	fResultClassNameToExtension= new HashMap<>();
44	44	fExtensions= Platform.getExtensionRegistry().getConfigurationElementsFor(ID_EXTENSION_POINT);
45		for (int i= 0; i < fExtensions.length; i++) {
46		fResultClassNameToExtension.put(fExtensions[i].getAttribute(ATTRIB_SEARCH_RESULT_CLASS), fExtensions[i]);
	45	for (IConfigurationElement fExtension : fExtensions) {
	46	fResultClassNameToExtension.put(fExtension.getAttribute(ATTRIB_SEARCH_RESULT_CLASS), fExtension);
47	47	}
48	48	}
49	49

107	107	}
108	108
109	109	private IConfigurationElement findConfigurationElement(String pageId) {
110		for (int i= 0; i < fExtensions.length; i++) {
111		IConfigurationElement curr= fExtensions[i];
	110	for (IConfigurationElement curr : fExtensions) {
112	111	if (pageId.equals(curr.getAttribute(ATTRIB_ID))) {
113	112	return curr;
114	113	}

132	131	}
133	132
134	133	Class<?>[] interfaces= resultClass.getInterfaces();
135		for (int i= 0; i < interfaces.length; i++) {
136		IConfigurationElement foundExtension= findConfigurationElement(interfaces[i]);
	134	for (Class<?> interface1 : interfaces) {
	135	IConfigurationElement foundExtension= findConfigurationElement(interface1);
137	136	if (foundExtension != null) {
138	137	fResultClassNameToExtension.put(className, configElement);
139	138	return foundExtension;

+5

-8

org.eclipse.search/new search/org/eclipse/search2/internal/ui/SearchView.java less more

14	14	package org.eclipse.search2.internal.ui;
15	15
16	16	import java.util.HashMap;
17		import java.util.Iterator;
18	17	import java.util.Map.Entry;
19	18
20	19	import com.ibm.icu.text.MessageFormat;

555	554	int bestActivation= -1;
556	555	IMemento restorePageMemento= null;
557	556	IMemento[] children= fPageState.getChildren(MEMENTO_TYPE);
558		for (int i= 0; i < children.length; i++) {
559		IMemento pageMemento= children[i];
	557	for (IMemento pageMemento : children) {
560	558	if (pageMemento.getString(MEMENTO_KEY_RESTORE) != null) {
561	559	Integer lastActivation= pageMemento.getInteger(MEMENTO_KEY_LAST_ACTIVATION);
562	560	if (lastActivation != null && lastActivation.intValue() > bestActivation) {

689	687
690	688	@Override
691	689	public void saveState(IMemento memento) {
692		for (Iterator<Entry<ISearchResultPage, DummyPart>> iter= fPagesToParts.entrySet().iterator(); iter.hasNext();) {
693		Entry<ISearchResultPage, DummyPart> entry= iter.next();
	690	for (Entry<ISearchResultPage, DummyPart> entry : fPagesToParts.entrySet()) {
694	691	ISearchResultPage page= entry.getKey();
695	692	DummyPart part= entry.getValue();
696	693

724	721	IMemento memento= null;
725	722	if (fPageState != null) {
726	723	IMemento[] mementos= fPageState.getChildren(MEMENTO_TYPE);
727		for (int i= 0; i < mementos.length; i++) {
728		if (mementos[i].getID().equals(srPage.getID())) {
729		memento= mementos[i];
	724	for (IMemento memento2 : mementos) {
	725	if (memento2.getID().equals(srPage.getID())) {
	726	memento= memento2;
730	727	break;
731	728	}
732	729	}

+3

-7

org.eclipse.search/new search/org/eclipse/search2/internal/ui/SearchViewManager.java less more

10	10
11	11	package org.eclipse.search2.internal.ui;
12	12
13		import java.util.Iterator;
14	13	import java.util.LinkedList;
15	14
16	15	import org.eclipse.ui.IViewReference;

119	118	}
120	119
121	120	public boolean isShown(ISearchQuery query) {
122		for (Iterator<SearchView> iter= fLRUSearchViews.iterator(); iter.hasNext();) {
123		SearchView view= iter.next();
	121	for (SearchView view : fLRUSearchViews) {
124	122	ISearchResult currentSearchResult= view.getCurrentSearchResult();
125	123	if (currentSearchResult != null && query == currentSearchResult.getQuery()) {
126	124	return true;

141	139
142	140	private ISearchResultViewPart findLRUSearchResultView(IWorkbenchPage page, boolean avoidPinnedViews) {
143	141	boolean viewFoundInPage= false;
144		for (Iterator<SearchView> iter= fLRUSearchViews.iterator(); iter.hasNext();) {
145		SearchView view= iter.next();
	142	for (SearchView view : fLRUSearchViews) {
146	143	if (page.equals(view.getSite().getPage())) {
147	144	if (!avoidPinnedViews \|\| !view.isPinned()) {
148	145	return view;

153	150	if (!viewFoundInPage) {
154	151	// find unresolved views
155	152	IViewReference[] viewReferences= page.getViewReferences();
156		for (int i= 0; i < viewReferences.length; i++) {
157		IViewReference curr= viewReferences[i];
	153	for (IViewReference curr : viewReferences) {
158	154	if (NewSearchUI.SEARCH_VIEW_ID.equals(curr.getId()) && page.equals(curr.getPage())) {
159	155	SearchView view= (SearchView) curr.getView(true);
160	156	if (view != null && (!avoidPinnedViews \|\| !view.isPinned())) {

+2

-2

org.eclipse.search/new search/org/eclipse/search2/internal/ui/ShowSearchHistoryDialogAction.java less more

43	43	ISearchQuery[] queries= NewSearchUI.getQueries();
44	44
45	45	ArrayList<ISearchResult> input= new ArrayList<>();
46		for (int j= 0; j < queries.length; j++) {
47		ISearchResult search= queries[j].getSearchResult();
	46	for (ISearchQuery query : queries) {
	47	ISearchResult search= query.getSearchResult();
48	48	input.add(search);
49	49	}
50	50

+7

-1

org.eclipse.search/new search/org/eclipse/search2/internal/ui/basic/views/ExpandAllAction.java less more

6	6	*
7	7	* Contributors:
8	8	* IBM Corporation - initial API and implementation
	9	* Karsten Thoms <karsten.thoms@itemis.de> Bug 522335
9	10	*******************************************************************************/
10	11	package org.eclipse.search2.internal.ui.basic.views;
11	12

33	34	@Override
34	35	public void run() {
35	36	if (fViewer != null) {
36		fViewer.expandAll();
	37	fViewer.getTree().setRedraw(false);
	38	try {
	39	fViewer.expandAll();
	40	} finally {
	41	fViewer.getTree().setRedraw(true);
	42	}
37	43	}
38	44	}
39	45	}

+3

-3

org.eclipse.search/new search/org/eclipse/search2/internal/ui/basic/views/TreeViewerNavigator.java less more

51	51	TreeItem[] roots= fViewer.getTree().getItems();
52	52	if (roots.length == 0)
53	53	return null;
54		for (int i = 0; i < roots.length; i++) {
55		if (hasMatches(roots[i]))
56		return roots[i];
	54	for (TreeItem root : roots) {
	55	if (hasMatches(root))
	56	return root;
57	57	TreeItem firstChild= getFirstChildWithMatches(roots[0]);
58	58	if (firstChild != null)
59	59	return firstChild;

+9

-11

org.eclipse.search/new search/org/eclipse/search2/internal/ui/text/AnnotationHighlighter.java less more

13	13	import java.util.Collections;
14	14	import java.util.HashMap;
15	15	import java.util.HashSet;
16		import java.util.Iterator;
17	16	import java.util.Map;
18	17	import java.util.Map.Entry;
19	18	import java.util.Set;

52	51	@Override
53	52	public void addHighlights(Match[] matches) {
54	53	HashMap<Annotation, Position> map= new HashMap<>(matches.length);
55		for (int i= 0; i < matches.length; i++) {
56		int offset= matches[i].getOffset();
57		int length= matches[i].getLength();
	54	for (Match match : matches) {
	55	int offset= match.getOffset();
	56	int length= match.getLength();
58	57	if (offset >= 0 && length >= 0) {
59		Position position= createPosition(matches[i]);
	58	Position position= createPosition(match);
60	59	if (position != null) {
61		Annotation annotation= matches[i].isFiltered()
	60	Annotation annotation= match.isFiltered()
62	61	? new Annotation(SearchPlugin.FILTERED_SEARCH_ANNOTATION_TYPE, true, null)
63	62	: new Annotation(SearchPlugin.SEARCH_ANNOTATION_TYPE, true, null);
64		fMatchesToAnnotations.put(matches[i], annotation);
	63	fMatchesToAnnotations.put(match, annotation);
65	64	map.put(annotation, position);
66	65	}
67	66	}

96	95	@Override
97	96	public void removeHighlights(Match[] matches) {
98	97	HashSet<Annotation> annotations= new HashSet<>(matches.length);
99		for (int i= 0; i < matches.length; i++) {
100		Annotation annotation= fMatchesToAnnotations.remove(matches[i]);
	98	for (Match match : matches) {
	99	Annotation annotation= fMatchesToAnnotations.remove(match);
101	100	if (annotation != null) {
102	101	annotations.add(annotation);
103	102	}

137	136	Annotation[] annotationArray= new Annotation[annotations.size()];
138	137	ame.replaceAnnotations(annotations.toArray(annotationArray), Collections.emptyMap());
139	138	} else {
140		for (Iterator<Annotation> iter= annotations.iterator(); iter.hasNext();) {
141		Annotation element= iter.next();
	139	for (Annotation element : annotations) {
142	140	fModel.removeAnnotation(element);
143	141	}
144	142	}

+16

-23

org.eclipse.search/new search/org/eclipse/search2/internal/ui/text/EditorAccessHighlighter.java less more

12	12	import java.util.Collections;
13	13	import java.util.HashMap;
14	14	import java.util.HashSet;
15		import java.util.Iterator;
16	15	import java.util.Map;
17	16	import java.util.Map.Entry;
18	17	import java.util.Set;

50	49	@Override
51	50	public void addHighlights(Match[] matches) {
52	51	Map<IAnnotationModel, HashMap<Annotation, Position>> mapsByAnnotationModel= new HashMap<>();
53		for (int i= 0; i < matches.length; i++) {
54		int offset= matches[i].getOffset();
55		int length= matches[i].getLength();
	52	for (Match match : matches) {
	53	int offset= match.getOffset();
	54	int length= match.getLength();
56	55	if (offset >= 0 && length >= 0) {
57	56	try {
58		Position position= createPosition(matches[i]);
	57	Position position= createPosition(match);
59	58	if (position != null) {
60		Map<Annotation, Position> map= getMap(mapsByAnnotationModel, matches[i]);
	59	Map<Annotation, Position> map= getMap(mapsByAnnotationModel, match);
61	60	if (map != null) {
62		Annotation annotation= matches[i].isFiltered()
	61	Annotation annotation= match.isFiltered()
63	62	? new Annotation(SearchPlugin.FILTERED_SEARCH_ANNOTATION_TYPE, true, null)
64	63	: new Annotation(SearchPlugin.SEARCH_ANNOTATION_TYPE, true, null);
65		fMatchesToAnnotations.put(matches[i], annotation);
	64	fMatchesToAnnotations.put(match, annotation);
66	65	map.put(annotation, position);
67	66	}
68	67	}

123	122	@Override
124	123	public void removeHighlights(Match[] matches) {
125	124	Map<IAnnotationModel, HashSet<Annotation>> setsByAnnotationModel= new HashMap<>();
126		for (int i= 0; i < matches.length; i++) {
127		Annotation annotation= fMatchesToAnnotations.remove(matches[i]);
	125	for (Match match : matches) {
	126	Annotation annotation= fMatchesToAnnotations.remove(match);
128	127	if (annotation != null) {
129		Set<Annotation> annotations= getSet(setsByAnnotationModel, matches[i]);
	128	Set<Annotation> annotations= getSet(setsByAnnotationModel, match);
130	129	if (annotations != null)
131	130	annotations.add(annotation);
132	131	}
133	132	}
134	133
135		for (Iterator<IAnnotationModel> maps= setsByAnnotationModel.keySet().iterator(); maps.hasNext();) {
136		IAnnotationModel model= maps.next();
137		Set<Annotation> set= setsByAnnotationModel.get(model);
138		removeAnnotations(model, set);
	134	for (Entry<IAnnotationModel, HashSet<Annotation>> entry : setsByAnnotationModel.entrySet()) {
	135	removeAnnotations(entry.getKey(), entry.getValue());
139	136	}
140	137
141	138	}

145	142	IAnnotationModelExtension ame= (IAnnotationModelExtension) model;
146	143	ame.replaceAnnotations(new Annotation[0], annotationToPositionMap);
147	144	} else {
148		for (Iterator<Annotation> elements= annotationToPositionMap.keySet().iterator(); elements.hasNext();) {
149		Annotation element= elements.next();
150		Position p= annotationToPositionMap.get(element);
151		model.addAnnotation(element, p);
	145	for (Entry<Annotation, Position> entry : annotationToPositionMap.entrySet()) {
	146	model.addAnnotation(entry.getKey(), entry.getValue());
152	147	}
153	148	}
154	149	}

166	161	Annotation[] annotationArray= new Annotation[annotations.size()];
167	162	ame.replaceAnnotations(annotations.toArray(annotationArray), Collections.emptyMap());
168	163	} else {
169		for (Iterator<Annotation> iter= annotations.iterator(); iter.hasNext();) {
170		Annotation element= iter.next();
	164	for (Annotation element : annotations) {
171	165	model.removeAnnotation(element);
172	166	}
173	167	}

186	180	return;
187	181	IDocument document= null;
188	182	ITextFileBuffer textBuffer= (ITextFileBuffer) buffer;
189		for (Iterator<Match> matches = fMatchesToAnnotations.keySet().iterator(); matches.hasNext();) {
190		Match match = matches.next();
	183	for (Match match : fMatchesToAnnotations.keySet()) {
191	184	document= fEditorAcess.getDocument(match);
192	185	if (document != null)
193	186	break;

+1

-2

org.eclipse.search/new search/org/eclipse/search2/internal/ui/text/EditorAnnotationManager.java less more

154	154	}
155	155
156	156	ArrayList<Match> matchesInEditor= null; // lazy initialization
157		for (int i= 0; i < matches.length; i++) {
158		Match curr= matches[i];
	157	for (Match curr : matches) {
159	158	if (adapter.isShownInEditor(curr, fEditor)) {
160	159	if (matchesInEditor == null) {
161	160	matchesInEditor= new ArrayList<>();

+5

-5

org.eclipse.search/new search/org/eclipse/search2/internal/ui/text/MarkerHighlighter.java less more

46	46	SearchPlugin.getWorkspace().run(new IWorkspaceRunnable() {
47	47	@Override
48	48	public void run(IProgressMonitor monitor) throws CoreException {
49		for (int i = 0; i < matches.length; i++) {
	49	for (Match match : matches) {
50	50	IMarker marker;
51		marker = createMarker(matches[i]);
	51	marker = createMarker(match);
52	52	if (marker != null)
53		fMatchesToAnnotations.put(matches[i], marker);
	53	fMatchesToAnnotations.put(match, marker);
54	54	}
55	55	}
56	56	}, fFile, IWorkspace.AVOID_UPDATE, null);

86	86
87	87	@Override
88	88	public void removeHighlights(Match[] matches) {
89		for (int i= 0; i < matches.length; i++) {
90		IMarker marker= fMatchesToAnnotations.remove(matches[i]);
	89	for (Match match : matches) {
	90	IMarker marker= fMatchesToAnnotations.remove(match);
91	91	if (marker != null) {
92	92	try {
93	93	marker.delete();

+9

-12

org.eclipse.search/new search/org/eclipse/search2/internal/ui/text/PositionTracker.java less more

11	11
12	12	import java.util.HashMap;
13	13	import java.util.HashSet;
14		import java.util.Iterator;
15	14	import java.util.Map;
16	15	import java.util.Set;
17	16

85	84	Match[] matches = evt.getMatches();
86	85	int kind = evt.getKind();
87	86	AbstractTextSearchResult result = (AbstractTextSearchResult) e.getSearchResult();
88		for (int i = 0; i < matches.length; i++) {
89		ITextFileBuffer fb= getTrackedFileBuffer(result, matches[i].getElement());
	87	for (Match match : matches) {
	88	ITextFileBuffer fb= getTrackedFileBuffer(result, match.getElement());
90	89	if (fb != null) {
91		updateMatch(matches[i], fb, kind, result);
	90	updateMatch(match, fb, kind, result);
92	91	}
93	92	}
94	93	} else if (e instanceof RemoveAllEvent) {

108	107
109	108	private void untrackAll(AbstractTextSearchResult result) {
110	109	Set<Match> matchSet= new HashSet<>(fMatchesToPositions.keySet());
111		for (Iterator<Match> matches= matchSet.iterator(); matches.hasNext();) {
112		Match match= matches.next();
	110	for (Match match : matchSet) {
113	111	AbstractTextSearchResult matchContainer= fMatchesToSearchResults.get(match);
114	112	if (result.equals(matchContainer)) {
115	113	ITextFileBuffer fb= getTrackedFileBuffer(result, match.getElement());

248	246	return;
249	247
250	248	ISearchQuery[] queries= NewSearchUI.getQueries();
251		for (int i = 0; i < queries.length; i++) {
252		ISearchResult result = queries[i].getSearchResult();
	249	for (ISearchQuery query : queries) {
	250	ISearchResult result = query.getSearchResult();
253	251	if (result instanceof AbstractTextSearchResult) {
254	252	AbstractTextSearchResult textResult = (AbstractTextSearchResult) result;
255	253	IFileMatchAdapter adapter = textResult.getFileMatchAdapter();
256	254	if (adapter != null) {
257	255	Match[] matches = adapter.computeContainedMatches(textResult, file);
258		for (int j = 0; j < matches.length; j++) {
	256	for (Match match : matches) {
259	257	trackCount[0]++;
260		trackPosition((AbstractTextSearchResult) result, (ITextFileBuffer) buffer, matches[j]);
	258	trackPosition((AbstractTextSearchResult) result, (ITextFileBuffer) buffer, match);
261	259	}
262	260	}
263	261	}

270	268	Set<Match> matches= fFileBuffersToMatches.get(buffer);
271	269	if (matches != null) {
272	270	Set<Match> matchSet= new HashSet<>(matches);
273		for (Iterator<Match> matchIterator= matchSet.iterator(); matchIterator.hasNext();) {
274		Match element= matchIterator.next();
	271	for (Match element : matchSet) {
275	272	operation.run((ITextFileBuffer) buffer, element);
276	273	}
277	274	}

+8

-12

org.eclipse.search/new search/org/eclipse/search2/internal/ui/text/WindowAnnotationManager.java less more

11	11
12	12	import java.util.ArrayList;
13	13	import java.util.HashMap;
14		import java.util.Iterator;
15	14	import java.util.Map;
16	15
17	16	import org.eclipse.ui.IEditorPart;

102	101
103	102	private void initEditors() {
104	103	IWorkbenchPage[] pages= fWindow.getPages();
105		for (int i = 0; i < pages.length; i++) {
106		IEditorReference[] editors= pages[i].getEditorReferences();
107		for (int j = 0; j < editors.length; j++) {
108		IEditorPart editor= editors[j].getEditor(false);
109		if (editor != null && pages[i].isPartVisible(editor)) {
	104	for (IWorkbenchPage page : pages) {
	105	IEditorReference[] editors= page.getEditorReferences();
	106	for (IEditorReference editor2 : editors) {
	107	IEditorPart editor= editor2.getEditor(false);
	108	if (editor != null && page.isPartVisible(editor)) {
110	109	startHighlighting(editor);
111	110	}
112	111	}

130	129
131	130	void dispose() {
132	131	fWindow.getPartService().removePartListener(fPartListener);
133		for (Iterator<EditorAnnotationManager> mgrs = fAnnotationManagers.values().iterator(); mgrs.hasNext();) {
134		EditorAnnotationManager mgr = mgrs.next();
	132	for (EditorAnnotationManager mgr : fAnnotationManagers.values()) {
135	133	mgr.dispose();
136	134	}
137	135	fAnnotationManagers= null;

141	139	boolean alreadyShown= fSearchResults.contains(result);
142	140	fSearchResults.add(result);
143	141	if (!alreadyShown) {
144		for (Iterator<EditorAnnotationManager> mgrs = fAnnotationManagers.values().iterator(); mgrs.hasNext();) {
145		EditorAnnotationManager mgr = mgrs.next();
	142	for (EditorAnnotationManager mgr : fAnnotationManagers.values()) {
146	143	mgr.addSearchResult(result);
147	144	}
148	145	}

152	149	fSearchResults.remove(result);
153	150	boolean stillShown= fSearchResults.contains(result);
154	151	if (!stillShown) {
155		for (Iterator<EditorAnnotationManager> mgrs = fAnnotationManagers.values().iterator(); mgrs.hasNext();) {
156		EditorAnnotationManager mgr = mgrs.next();
	152	for (EditorAnnotationManager mgr : fAnnotationManagers.values()) {
157	153	mgr.removeSearchResult(result);
158	154	}
159	155	}

+2

-4

org.eclipse.search/new search/org/eclipse/search2/internal/ui/text2/TextSearchQueryProviderRegistry.java less more

72	72	@Override
73	73	public void run() throws Exception {
74	74	IConfigurationElement[] extensions= Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_POINT_ID);
75		for (int i= 0; i < extensions.length; i++) {
76		IConfigurationElement curr= extensions[i];
	75	for (IConfigurationElement curr : extensions) {
77	76	if (PROVIDER_NODE_NAME.equals(curr.getName()) && id.equals(curr.getAttribute(ATTRIB_ID))) {
78	77	res[0]= (TextSearchQueryProvider) curr.createExecutableExtension(ATTRIB_CLASS);
79	78	return;

94	93	res.add(new String[] { SearchMessages.TextSearchQueryProviderRegistry_defaultProviderLabel, "" }); //$NON-NLS-1$
95	94
96	95	IConfigurationElement[] extensions= Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_POINT_ID);
97		for (int i= 0; i < extensions.length; i++) {
98		IConfigurationElement engine= extensions[i];
	96	for (IConfigurationElement engine : extensions) {
99	97	if (PROVIDER_NODE_NAME.equals(engine.getName())) {
100	98	res.add(new String[] { engine.getAttribute(ATTRIB_LABEL), engine.getAttribute(ATTRIB_ID) });
101	99	}

+2

-2

org.eclipse.search/pom.xml less more

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<groupId>org.eclipse.search</groupId>
19	19	<artifactId>org.eclipse.search</artifactId>
20		<version>3.11.100-SNAPSHOT</version>
	20	<version>3.11.200-SNAPSHOT</version>
21	21	<packaging>eclipse-plugin</packaging>
22	22	</project>

+4

-4

org.eclipse.search/search/org/eclipse/search/internal/core/text/FileCharSequenceProvider.java less more

186	186	return fBuf[pos - fOffset];
187	187	}
188	188
189		public StringBuffer append(StringBuffer buf, int start, int length) {
	189	public StringBuilder append(StringBuilder buf, int start, int length) {
190	190	return buf.append(fBuf, start - fOffset, length);
191	191	}
192	192
193		public StringBuffer appendAll(StringBuffer buf) {
	193	public StringBuilder appendAll(StringBuilder buf) {
194	194	return buf.append(fBuf, 0, fLength);
195	195	}
196	196

426	426	throw new IndexOutOfBoundsException("end must be smaller than length"); //$NON-NLS-1$
427	427	}
428	428
429		StringBuffer res= new StringBuffer(length);
	429	StringBuilder res= new StringBuilder(length);
430	430
431	431	Buffer buffer= getBuffer(pos);
432	432	while (pos < endPos && buffer != null) {

463	463	@Override
464	464	public String toString() {
465	465	int len= fLength != null ? fLength.intValue() : 4000;
466		StringBuffer res= new StringBuffer(len);
	466	StringBuilder res= new StringBuilder(len);
467	467	try {
468	468	Buffer buffer= getBuffer(0);
469	469	while (buffer != null) {

+2

-3

org.eclipse.search/search/org/eclipse/search/internal/core/text/FileNamePatternSearchScope.java less more

142	142	public String getFileNamePatternDescription() {
143	143	String[] ext= fFileNamePatterns.toArray(new String[fFileNamePatterns.size()]);
144	144	Arrays.sort(ext);
145		StringBuffer buf= new StringBuffer();
	145	StringBuilder buf= new StringBuilder();
146	146	for (int i= 0; i < ext.length; i++) {
147	147	if (i > 0) {
148	148	buf.append(", "); //$NON-NLS-1$

155	155
156	156	private static IResource[] removeRedundantEntries(IResource[] elements, boolean includeDerived) {
157	157	ArrayList<IResource> res= new ArrayList<>();
158		for (int i= 0; i < elements.length; i++) {
159		IResource curr= elements[i];
	158	for (IResource curr : elements) {
160	159	addToList(res, curr, includeDerived);
161	160	}
162	161	return res.toArray(new IResource[res.size()]);

+1

-2

org.eclipse.search/search/org/eclipse/search/internal/core/text/FilesOfScopeCalculator.java less more

46	46	fFiles= new ArrayList<>();
47	47	try {
48	48	IResource[] roots= fScope.getRoots();
49		for (int i= 0; i < roots.length; i++) {
	49	for (IResource resource : roots) {
50	50	try {
51		IResource resource= roots[i];
52	51	if (resource.isAccessible()) {
53	52	resource.accept(this, 0);
54	53	}

+7

-7

org.eclipse.search/search/org/eclipse/search/internal/core/text/PatternConstructor.java less more

52	52	Assert.isTrue(!isWholeWord, "isWholeWord unsupported together with isRegex"); //$NON-NLS-1$
53	53	} else {
54	54	int len= pattern.length();
55		StringBuffer buffer= new StringBuffer(len + 10);
	55	StringBuilder buffer= new StringBuilder(len + 10);
56	56	// don't add a word boundary if the search text does not start with
57	57	// a word char. (this works around a user input error).
58	58	if (isWholeWord && len > 0 && isWordChar(pattern.charAt(0))) {

81	81	*/
82	82	private static String substituteLinebreak(String findString) throws PatternSyntaxException {
83	83	int length= findString.length();
84		StringBuffer buf= new StringBuffer(length);
	84	StringBuilder buf= new StringBuilder(length);
85	85
86	86	int inCharGroup= 0;
87	87	int inBraces= 0;

165	165	* @throws PatternSyntaxException if "\R" is at an illegal position
166	166	*/
167	167	public static Pattern createPattern(String[] patterns, boolean isCaseSensitive) throws PatternSyntaxException {
168		StringBuffer pattern= new StringBuffer();
	168	StringBuilder pattern= new StringBuilder();
169	169	for (int i= 0; i < patterns.length; i++) {
170	170	if (i > 0) {
171	171	// note that this works only as we know that the operands of the

178	178	}
179	179
180	180
181		public static StringBuffer appendAsRegEx(boolean isStringMatcher, String pattern, StringBuffer buffer) {
	181	public static StringBuilder appendAsRegEx(boolean isStringMatcher, String pattern, StringBuilder buffer) {
182	182	boolean isEscaped= false;
183	183	for (int i = 0; i < pattern.length(); i++) {
184	184	char c = pattern.charAt(i);

296	296	private String interpretReplaceEscapes(String replaceText, String foundText) {
297	297	int length= replaceText.length();
298	298	boolean inEscape= false;
299		StringBuffer buf= new StringBuffer(length);
	299	StringBuilder buf= new StringBuilder(length);
300	300
301	301	/* every string we did not check looks mixed at first
302	302	* so initialize retain case mode with RC_MIXED

357	357	* @return the new offset
358	358	* @since 3.4
359	359	*/
360		private int interpretReplaceEscape(final char ch, int i, StringBuffer buf, String replaceText, String foundText) {
	360	private int interpretReplaceEscape(final char ch, int i, StringBuilder buf, String replaceText, String foundText) {
361	361	int length= replaceText.length();
362	362	switch (ch) {
363	363	case 'r':

487	487	* @param ch the character to process
488	488	* @since 3.4
489	489	*/
490		private void interpretRetainCase(StringBuffer buf, char ch) {
	490	private void interpretRetainCase(StringBuilder buf, char ch) {
491	491	if (fRetainCaseMode == RC_UPPER)
492	492	buf.append(String.valueOf(ch).toUpperCase());
493	493	else if (fRetainCaseMode == RC_LOWER)

+2

-4

org.eclipse.search/search/org/eclipse/search/internal/core/text/TextSearchEngineRegistry.java less more

81	81	@Override
82	82	public void run() throws Exception {
83	83	IConfigurationElement[] extensions= Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_POINT_ID);
84		for (int i= 0; i < extensions.length; i++) {
85		IConfigurationElement curr= extensions[i];
	84	for (IConfigurationElement curr : extensions) {
86	85	if (ENGINE_NODE_NAME.equals(curr.getName()) && id.equals(curr.getAttribute(ATTRIB_ID))) {
87	86	res[0]= (TextSearchEngine) curr.createExecutableExtension(ATTRIB_CLASS);
88	87	return;

103	102	res.add(new String[] { SearchMessages.TextSearchEngineRegistry_defaulttextsearch_label, "" }); //$NON-NLS-1$
104	103
105	104	IConfigurationElement[] extensions= Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_POINT_ID);
106		for (int i= 0; i < extensions.length; i++) {
107		IConfigurationElement engine= extensions[i];
	105	for (IConfigurationElement engine : extensions) {
108	106	if (ENGINE_NODE_NAME.equals(engine.getName())) {
109	107	res.add(new String[] { engine.getAttribute(ATTRIB_LABEL), engine.getAttribute(ATTRIB_ID) });
110	108	}

+54

-48

org.eclipse.search/search/org/eclipse/search/internal/core/text/TextSearchVisitor.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2016 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

18	18	import java.util.ArrayList;
19	19	import java.util.Arrays;
20	20	import java.util.Collections;
21		import java.util.Comparator;
22	21	import java.util.HashMap;
23	22	import java.util.List;
24	23	import java.util.Map;

80	79	public static final boolean TRACING= "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.search/perf")); //$NON-NLS-1$ //$NON-NLS-2$
81	80	private static final int NUMBER_OF_LOGICAL_THREADS= Runtime.getRuntime().availableProcessors();
82	81	private static final int FILES_PER_JOB= 50;
	82	private static final int MAX_JOBS_COUNT= 100;
83	83
84	84	public static class ReusableMatchAccess extends TextSearchMatchAccess {
85	85

168	168	public TextSearchJob(IFile[] files, int begin, int end, Map<IFile, IDocument> documentsInEditors) {
169	169	super(files[begin].getName());
170	170	setSystem(true);
171		fFiles = files;
172		fBegin = begin;
173		fEnd = end;
174		fDocumentsInEditors = documentsInEditors;
	171	fFiles= files;
	172	fBegin= begin;
	173	fEnd= end;
	174	fDocumentsInEditors= documentsInEditors;
175	175	}
176	176
177	177	@Override
178	178	protected IStatus run(IProgressMonitor inner) {
179	179	MultiStatus multiStatus=
180	180	new MultiStatus(NewSearchUI.PLUGIN_ID, IStatus.OK, SearchMessages.TextSearchEngine_statusMessage, null);
181		SubMonitor subMonitor = SubMonitor.convert(inner, fEnd - fBegin);
182		this.fileCharSequenceProvider = new FileCharSequenceProvider();
183		for (int i = fBegin; i < fEnd && !fFatalError; i++) {
	181	SubMonitor subMonitor= SubMonitor.convert(inner, fEnd - fBegin);
	182	this.fileCharSequenceProvider= new FileCharSequenceProvider();
	183	for (int i= fBegin; i < fEnd && !fFatalError; i++) {
184	184	IStatus status= processFile(fFiles[i], subMonitor.split(1));
185	185	// Only accumulate interesting status
186	186	if (!status.isOK())

193	193	fileCharSequenceProvider.releaseCharSequence(charsequenceForPreviousLocation);
194	194	} catch (IOException e) {
195	195	SearchPlugin.log(e);
196		}
197		}
	196	} finally {
	197	charsequenceForPreviousLocation= null;
	198	}
	199	}
	200	fileCharSequenceProvider= null;
	201	previousLocationFromFile= null;
	202	occurencesForPreviousLocation= null;
198	203	return multiStatus;
199	204	}
200	205

215	220	locateMatches(file, documentCharSequence, matcher, monitor);
216	221	} else if (previousLocationFromFile != null && previousLocationFromFile.equals(file.getLocation()) && !occurencesForPreviousLocation.isEmpty()) {
217	222	// reuse previous result
218		ReusableMatchAccess matchAccess = new ReusableMatchAccess();
	223	ReusableMatchAccess matchAccess= new ReusableMatchAccess();
219	224	for (TextSearchMatchAccess occurence : occurencesForPreviousLocation) {
220	225	matchAccess.initialize(file, occurence.getMatchOffset(), occurence.getMatchLength(), charsequenceForPreviousLocation);
221		boolean goOn = fCollector.acceptPatternMatch(matchAccess);
	226	boolean goOn= fCollector.acceptPatternMatch(matchAccess);
222	227	if (!goOn) {
223	228	break;
224	229	}

227	232	if (charsequenceForPreviousLocation != null) {
228	233	try {
229	234	fileCharSequenceProvider.releaseCharSequence(charsequenceForPreviousLocation);
230		charsequenceForPreviousLocation = null;
	235	charsequenceForPreviousLocation= null;
231	236	} catch (IOException e) {
232	237	SearchPlugin.log(e);
233	238	}

235	240	try {
236	241	charsequenceForPreviousLocation= fileCharSequenceProvider.newCharSequence(file);
237	242	if (hasBinaryContent(charsequenceForPreviousLocation, file) && !fCollector.reportBinaryFile(file)) {
238		occurencesForPreviousLocation = Collections.emptyList();
	243	occurencesForPreviousLocation= Collections.emptyList();
239	244	return Status.OK_STATUS;
240	245	}
241		occurencesForPreviousLocation = locateMatches(file, charsequenceForPreviousLocation, matcher, monitor);
242		previousLocationFromFile = file.getLocation();
	246	occurencesForPreviousLocation= locateMatches(file, charsequenceForPreviousLocation, matcher, monitor);
	247	previousLocationFromFile= file.getLocation();
243	248	} catch (FileCharSequenceProvider.FileCharSequenceException e) {
244	249	e.throwWrappedException();
245	250	}

264	269	String message= Messages.format(SearchMessages.TextSearchVisitor_error, args);
265	270	return new Status(IStatus.ERROR, NewSearchUI.PLUGIN_ID, IStatus.ERROR, message, e);
266	271	} catch (StackOverflowError e) {
267		fFatalError = true;
	272	fFatalError= true;
268	273	String message= SearchMessages.TextSearchVisitor_patterntoocomplex0;
269	274	return new Status(IStatus.ERROR, NewSearchUI.PLUGIN_ID, IStatus.ERROR, message, e);
270	275	} finally {

319	324	int jobCount= 1;
320	325	if (maxThreads > 1) {
321	326	jobCount= (files.length + FILES_PER_JOB - 1) / FILES_PER_JOB;
	327	}
	328	// Too many job references can cause OOM, see bug 514961
	329	if (jobCount > MAX_JOBS_COUNT) {
	330	jobCount= MAX_JOBS_COUNT;
322	331	}
323	332	final JobGroup jobGroup= new TextSearchJobGroup("Text Search", maxThreads, jobCount); //$NON-NLS-1$
324	333	long startTime= TRACING ? System.currentTimeMillis() : 0;

369	378	try {
370	379	fCollector.beginReporting();
371	380	Map<IFile, IDocument> documentsInEditors= PlatformUI.isWorkbenchRunning() ? evalNonFileBufferDocuments() : Collections.emptyMap();
372		int filesPerJob = (files.length + jobCount - 1) / jobCount;
373		IFile[] filesByLocation = new IFile[files.length];
	381	int filesPerJob = Math.max(1, files.length / jobCount);
	382	IFile[] filesByLocation= new IFile[files.length];
374	383	System.arraycopy(files, 0, filesByLocation, 0, files.length);
375	384	// Sorting files to search by location allows to more easily reuse
376	385	// search results from one file to the other when they have same location
377		Arrays.sort(filesByLocation, new Comparator<IFile>() {
378		@Override
379		public int compare(IFile o1, IFile o2) {
380		if (o1 == o2) {
381		return 0;
382		}
383		if (o1.getLocation() == o2.getLocation()) {
384		return 0;
385		}
386		if (o1.getLocation() == null) {
387		return +1;
388		}
389		if (o2.getLocation() == null) {
390		return -1;
391		}
392		return o1.getLocation().toString().compareTo(o2.getLocation().toString());
393		}
	386	Arrays.sort(filesByLocation, (o1, o2) -> {
	387	if (o1 == o2) {
	388	return 0;
	389	}
	390	if (o1.getLocation() == o2.getLocation()) {
	391	return 0;
	392	}
	393	if (o1.getLocation() == null) {
	394	return +1;
	395	}
	396	if (o2.getLocation() == null) {
	397	return -1;
	398	}
	399	return o1.getLocation().toString().compareTo(o2.getLocation().toString());
394	400	});
395	401	for (int first= 0; first < filesByLocation.length; first += filesPerJob) {
396	402	int end= Math.min(filesByLocation.length, first + filesPerJob);

416	422	fProgressMonitor.done();
417	423	fCollector.endReporting();
418	424	if (TRACING) {
419		Object[] args= { Integer.valueOf(fNumberOfScannedFiles), Integer.valueOf(jobCount), Integer.valueOf(NUMBER_OF_LOGICAL_THREADS), new Long(System.currentTimeMillis() - startTime) };
	425	Object[] args= { Integer.valueOf(fNumberOfScannedFiles), Integer.valueOf(jobCount), Integer.valueOf(NUMBER_OF_LOGICAL_THREADS), Long.valueOf(System.currentTimeMillis() - startTime) };
420	426	System.out.println(Messages.format(
421	427	"[TextSearch] Search duration for {0} files in {1} jobs using {2} threads: {3}ms", args)); //$NON-NLS-1$
422	428	}

437	443	Map<IFile, IDocument> result= new HashMap<>();
438	444	IWorkbench workbench= SearchPlugin.getDefault().getWorkbench();
439	445	IWorkbenchWindow[] windows= workbench.getWorkbenchWindows();
440		for (int i= 0; i < windows.length; i++) {
441		IWorkbenchPage[] pages= windows[i].getPages();
442		for (int x= 0; x < pages.length; x++) {
443		IEditorReference[] editorRefs= pages[x].getEditorReferences();
444		for (int z= 0; z < editorRefs.length; z++) {
445		IEditorPart ep= editorRefs[z].getEditor(false);
	446	for (IWorkbenchWindow window : windows) {
	447	IWorkbenchPage[] pages= window.getPages();
	448	for (IWorkbenchPage page : pages) {
	449	IEditorReference[] editorRefs= page.getEditorReferences();
	450	for (IEditorReference editorRef : editorRefs) {
	451	IEditorPart ep= editorRef.getEditor(false);
446	452	if (ep instanceof ITextEditor && ep.isDirty()) { // only dirty editors
447	453	evaluateTextEditor(result, ep);
448	454	}

501	507	}
502	508
503	509	private List<TextSearchMatchAccess> locateMatches(IFile file, CharSequence searchInput, Matcher matcher, IProgressMonitor monitor) throws CoreException {
504		List<TextSearchMatchAccess> occurences = null;
	510	List<TextSearchMatchAccess> occurences= null;
505	511	matcher.reset(searchInput);
506	512	int k= 0;
507	513	while (matcher.find()) {
508	514	if (occurences == null) {
509		occurences = new ArrayList<>();
	515	occurences= new ArrayList<>();
510	516	}
511	517	int start= matcher.start();
512	518	int end= matcher.end();
513	519	if (end != start) { // don't report 0-length matches
514		ReusableMatchAccess access = new ReusableMatchAccess();
	520	ReusableMatchAccess access= new ReusableMatchAccess();
515	521	access.initialize(file, start, end - start, searchInput);
516	522	occurences.add(access);
517	523	boolean res= fCollector.acceptPatternMatch(access);

525	531	}
526	532	}
527	533	if (occurences == null) {
528		occurences = Collections.emptyList();
	534	occurences= Collections.emptyList();
529	535	}
530	536	return occurences;
531	537	}

+1

-1

org.eclipse.search/search/org/eclipse/search/internal/ui/CopyToClipboardAction.java less more

107	107
108	108	IBaseLabelProvider labelProvider= fViewer.getLabelProvider();
109	109	String lineDelim= System.getProperty("line.separator"); //$NON-NLS-1$
110		StringBuffer buf= new StringBuffer();
	110	StringBuilder buf= new StringBuilder();
111	111	Iterator<?> iter= getSelection();
112	112	while (iter.hasNext()) {
113	113	if (buf.length() > 0) {

+3

-10

org.eclipse.search/search/org/eclipse/search/internal/ui/OpenSearchDialogPageAction.java less more

10	10	*******************************************************************************/
11	11	package org.eclipse.search.internal.ui;
12	12
13		import java.util.Iterator;
14	13	import java.util.List;
15	14
16	15	import org.eclipse.swt.events.MenuAdapter;

76	75	private void fillMenu(final Menu localMenu) {
77	76	List<SearchPageDescriptor> pageDescriptors= SearchPlugin.getDefault().getSearchPageDescriptors();
78	77	int accelerator= 1;
79		for (Iterator<SearchPageDescriptor> iter= pageDescriptors.iterator(); iter.hasNext();) {
80		SearchPageDescriptor desc= iter.next();
	78	for (SearchPageDescriptor desc : pageDescriptors) {
81	79	if (!WorkbenchActivityHelper.filterItem(desc) && desc.isEnabled()) {
82	80	SearchPageAction action= new SearchPageAction(fWorkbenchWindow, desc);
83	81	addToMenu(localMenu, action, accelerator++);

86	84	localMenu.addMenuListener(new MenuAdapter() {
87	85	@Override
88	86	public void menuHidden(MenuEvent e) {
89		e.display.asyncExec(new Runnable() {
90		@Override
91		public void run() {
92		localMenu.dispose();
93		}
94		});
	87	e.display.asyncExec(() -> localMenu.dispose());
95	88	}
96	89	});
97	90
98	91	}
99	92
100	93	private void addToMenu(Menu localMenu, IAction action, int accelerator) {
101		StringBuffer label= new StringBuffer();
	94	StringBuilder label= new StringBuilder();
102	95	if (accelerator >= 0 && accelerator < 10) {
103	96	//add the numerical accelerator
104	97	label.append('&');

+5

-8

org.eclipse.search/search/org/eclipse/search/internal/ui/RemoveResultAction.java less more

51	51	public void run() {
52	52	final IMarker[] markers= getMarkers(fSelectionProvider.getSelection());
53	53	if (markers != null) {
54		BusyIndicator.showWhile(SearchPlugin.getActiveWorkbenchShell().getDisplay(), new Runnable() {
55		@Override
56		public void run() {
57		try {
58		SearchPlugin.getWorkspace().deleteMarkers(markers);
59		} catch (CoreException ex) {
60		ExceptionHandler.handle(ex, SearchMessages.Search_Error_deleteMarkers_title, SearchMessages.Search_Error_deleteMarkers_message);
61		}
	54	BusyIndicator.showWhile(SearchPlugin.getActiveWorkbenchShell().getDisplay(), () -> {
	55	try {
	56	SearchPlugin.getWorkspace().deleteMarkers(markers);
	57	} catch (CoreException ex) {
	58	ExceptionHandler.handle(ex, SearchMessages.Search_Error_deleteMarkers_title, SearchMessages.Search_Error_deleteMarkers_message);
62	59	}
63	60	});
64	61	}

+83

-9

org.eclipse.search/search/org/eclipse/search/internal/ui/ScopePart.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2011 IBM Corporation and others.
	1	* Copyright (c) 2000, 2017 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

6	6	*
7	7	* Contributors:
8	8	* IBM Corporation - initial API and implementation
	9	* Lucas Bullen (Red Hat Inc.) - [Bug 526453] disambiguate "Selected Resources"
9	10	*******************************************************************************/
10	11	package org.eclipse.search.internal.ui;
11	12
	13	import java.util.ArrayList;
12	14	import java.util.Arrays;
	15	import java.util.Collections;
13	16	import java.util.HashSet;
	17	import java.util.Iterator;
	18	import java.util.List;
14	19	import java.util.Set;
	20
	21	import org.eclipse.osgi.util.NLS;
15	22
16	23	import org.eclipse.swt.SWT;
17	24	import org.eclipse.swt.accessibility.AccessibleAdapter;

26	33	import org.eclipse.swt.widgets.Text;
27	34
28	35	import org.eclipse.core.runtime.Assert;
	36	import org.eclipse.core.runtime.IAdaptable;
29	37	import org.eclipse.core.runtime.IStatus;
30	38	import org.eclipse.core.runtime.Status;
	39
	40	import org.eclipse.core.resources.IFile;
	41	import org.eclipse.core.resources.IResource;
31	42
32	43	import org.eclipse.jface.dialogs.IDialogSettings;
33	44	import org.eclipse.jface.layout.PixelConverter;

41	52	import org.eclipse.ui.PlatformUI;
42	53	import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog;
43	54
	55	import org.eclipse.search.internal.ui.text.LineElement;
44	56	import org.eclipse.search.internal.ui.util.SWTUtil;
45	57	import org.eclipse.search.ui.ISearchPageContainer;
46	58	import org.eclipse.search.ui.NewSearchUI;

125	137	IWorkingSetManager workingSetManager= PlatformUI.getWorkbench().getWorkingSetManager();
126	138	if (lruWorkingSetNames != null) {
127	139	Set<IWorkingSet> existingWorkingSets= new HashSet<>(lruWorkingSetNames.length);
128		for (int i= 0; i < lruWorkingSetNames.length; i++) {
129		IWorkingSet workingSet= getWorkingSet(workingSetManager, lruWorkingSetNames[i]);
	140	for (String lruWorkingSetName : lruWorkingSetNames) {
	141	IWorkingSet workingSet= getWorkingSet(workingSetManager, lruWorkingSetName);
130	142	if (workingSet != null) {
131	143	existingWorkingSets.add(workingSet);
132	144	}

147	159	return null;
148	160	}
149	161
	162	public static List<IResource> selectedResourcesFromContainer(ISearchPageContainer container) {
	163	if (container == null)
	164	return Collections.emptyList();
	165	ISelection selection = container.getSelection();
	166	List<IResource> resources = new ArrayList<>();
	167	if (!(selection instanceof IStructuredSelection) \|\| selection.isEmpty()) {
	168	if (container.getActiveEditorInput() != null) {
	169	resources.add(container.getActiveEditorInput().getAdapter(IFile.class));
	170	}
	171	return resources;
	172	}
	173	Iterator<?> iter = ((IStructuredSelection) selection).iterator();
	174	while (iter.hasNext()) {
	175	Object curr = iter.next();
	176	if (curr instanceof IWorkingSet) {
	177	IWorkingSet workingSet = (IWorkingSet) curr;
	178	if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
	179	continue;
	180	}
	181	IAdaptable[] elements = workingSet.getElements();
	182	for (IAdaptable element : elements) {
	183	IResource resource = element.getAdapter(IResource.class);
	184	if (resource != null && resource.isAccessible()) {
	185	resources.add(resource);
	186	}
	187	}
	188	} else if (curr instanceof LineElement) {
	189	IResource resource = ((LineElement) curr).getParent();
	190	if (resource != null && resource.isAccessible())
	191	resources.add(resource);
	192	} else if (curr instanceof IAdaptable) {
	193	IResource resource = ((IAdaptable) curr).getAdapter(IResource.class);
	194	if (resource != null && resource.isAccessible()) {
	195	resources.add(resource);
	196	}
	197	}
	198	}
	199	return resources;
	200	}
	201
	202	private String getSelectedResurcesButtonText() {
	203	int size = selectedResourcesFromContainer(fSearchDialog).size();
	204	if (size == 1) {
	205	if (fSearchDialog.getActiveEditor() != null)
	206	return SearchMessages.ScopePart_selectedResourcesScope_text_editor;
	207	return NLS.bind(SearchMessages.ScopePart_selectedResourcesScope_text_singular,
	208	fSearchDialog.getWorkbenchWindow().getActivePage().getActivePart().getTitle());
	209	}
	210	if (size > 1)
	211	return NLS.bind(SearchMessages.ScopePart_selectedResourcesScope_text_plural, Integer.valueOf(size),
	212	fSearchDialog.getWorkbenchWindow().getActivePage().getActivePart().getTitle());
	213	return SearchMessages.ScopePart_selectedResourcesScope_text;
	214	}
	215
	216	private String getEnclosingProjectsButtonText() {
	217	int size = fSearchDialog.getEnclosingProjectNames().length;
	218	if (size == 1)
	219	return SearchMessages.ScopePart_enclosingProjectsScope_text_singular;
	220	if (size > 1)
	221	return NLS.bind(SearchMessages.ScopePart_enclosingProjectsScope_text_plural, Integer.valueOf(size));
	222	return SearchMessages.ScopePart_enclosingProjectsScope_text;
	223	}
150	224
151	225	/**
152	226	* Returns the scope selected in this part

230	304	setSelectedScope(ISearchPageContainer.WORKING_SET_SCOPE);
231	305	fWorkingSets= null;
232	306	Set<IWorkingSet> existingWorkingSets= new HashSet<>(workingSets.length);
233		for (int i= 0; i < workingSets.length; i++) {
234		String name= workingSets[i].getName();
	307	for (IWorkingSet workingSet2 : workingSets) {
	308	String name= workingSet2.getName();
235	309	IWorkingSet workingSet= PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(name);
236	310	if (workingSet != null)
237	311	existingWorkingSets.add(workingSet);

282	356
283	357	fUseSelection= new Button(fPart, SWT.RADIO);
284	358	fUseSelection.setData(Integer.valueOf(ISearchPageContainer.SELECTION_SCOPE));
285		fUseSelection.setText(SearchMessages.ScopePart_selectedResourcesScope_text);
	359	fUseSelection.setText(getSelectedResurcesButtonText());
286	360
287	361	boolean canSearchInSelection= canSearchInSelection();
288	362	fUseSelection.setEnabled(canSearchInSelection);

293	367
294	368	fUseProject= new Button(fPart, SWT.RADIO);
295	369	fUseProject.setData(Integer.valueOf(ISearchPageContainer.SELECTED_PROJECTS_SCOPE));
296		fUseProject.setText(SearchMessages.ScopePart_enclosingProjectsScope_text);
	370	fUseProject.setText(getEnclosingProjectsButtonText());
297	371	fUseProject.setEnabled(fSearchDialog.getEnclosingProjectNames().length > 0);
298	372
299	373	gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);

416	490	if (workingSets != null && workingSets.length > 0) {
417	491	Arrays.sort(workingSets, new WorkingSetComparator());
418	492	boolean firstFound= false;
419		for (int i= 0; i < workingSets.length; i++) {
420		String workingSetName= workingSets[i].getLabel();
	493	for (IWorkingSet workingSet : workingSets) {
	494	String workingSetName= workingSet.getLabel();
421	495	if (firstFound)
422	496	result= Messages.format(SearchMessages.ScopePart_workingSetConcatenation, new String[] { result, workingSetName });
423	497	else {

+31

-55

org.eclipse.search/search/org/eclipse/search/internal/ui/SearchDialog.java less more

22	22	import org.eclipse.swt.custom.BusyIndicator;
23	23	import org.eclipse.swt.custom.CTabFolder;
24	24	import org.eclipse.swt.custom.CTabItem;
25		import org.eclipse.swt.events.DisposeEvent;
26		import org.eclipse.swt.events.DisposeListener;
27	25	import org.eclipse.swt.events.SelectionAdapter;
28	26	import org.eclipse.swt.events.SelectionEvent;
29	27	import org.eclipse.swt.events.SelectionListener;

61	59	import org.eclipse.jface.resource.ImageDescriptor;
62	60	import org.eclipse.jface.util.SafeRunnable;
63	61	import org.eclipse.jface.viewers.ArrayContentProvider;
64		import org.eclipse.jface.viewers.CheckStateChangedEvent;
65	62	import org.eclipse.jface.viewers.CheckboxTableViewer;
66		import org.eclipse.jface.viewers.ICheckStateListener;
67	63	import org.eclipse.jface.viewers.ILabelProvider;
68	64	import org.eclipse.jface.viewers.ISelection;
69	65	import org.eclipse.jface.viewers.IStructuredSelection;

106	102	int x= 0;
107	103	int y= 0;
108	104	Control[] children= composite.getChildren();
109		for (int i= 0; i < children.length; i++) {
110		Point size= children[i].computeSize(SWT.DEFAULT, SWT.DEFAULT, flushCache);
	105	for (Control element : children) {
	106	Point size= element.computeSize(SWT.DEFAULT, SWT.DEFAULT, flushCache);
111	107	x= Math.max(x, size.x);
112	108	y= Math.max(y, size.y);
113	109	}

127	123	Rectangle rect= composite.getClientArea();
128	124
129	125	Control[] children= composite.getChildren();
130		for (int i= 0; i < children.length; i++) {
131		children[i].setBounds(rect);
	126	for (Control element : children) {
	127	element.setBounds(rect);
132	128	}
133	129	}
134	130	}

203	199	IWorkingSet workingSet= (IWorkingSet) curr;
204	200	if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
205	201	IProject[] projects= ResourcesPlugin.getWorkspace().getRoot().getProjects();
206		for (int i= 0; i < projects.length; i++) {
207		IProject proj= projects[i];
	202	for (IProject proj : projects) {
208	203	if (proj.isOpen()) {
209	204	res.add(proj.getName());
210	205	}
211	206	}
212	207	} else {
213	208	IAdaptable[] elements= workingSet.getElements();
214		for (int i= 0; i < elements.length; i++) {
215		String name= evaluateEnclosingProject(elements[i]);
	209	for (IAdaptable element : elements) {
	210	String name= evaluateEnclosingProject(element);
216	211	if (name != null) {
217	212	res.add(name);
218	213	}

342	337	super.create();
343	338	final CheckboxTableViewer viewer= getViewer();
344	339	final Button okButton= this.getOkButton();
345		viewer.addCheckStateListener(new ICheckStateListener() {
346		@Override
347		public void checkStateChanged(CheckStateChangedEvent event) {
348		okButton.setEnabled(viewer.getCheckedElements().length > 0);
349		}
350		});
	340	viewer.addCheckStateListener(event -> okButton.setEnabled(viewer.getCheckedElements().length > 0));
351	341	SelectionListener listener = new SelectionAdapter() {
352	342	@Override
353	343	public void widgetSelected(SelectionEvent e) {

381	371	close();
382	372	if (display != null && !display.isDisposed()) {
383	373	display.asyncExec(
384		new Runnable() {
385		@Override
386		public void run() {
387		new OpenSearchDialogAction().run();
388		}
389		});
	374	() -> new OpenSearchDialogAction().run());
390	375	}
391	376	}
392	377	destroyImages(createdImages);

394	379
395	380	private List<SearchPageDescriptor> filterByActivities(List<SearchPageDescriptor> input) {
396	381	ArrayList<SearchPageDescriptor> filteredList= new ArrayList<>(input.size());
397		for (Iterator<SearchPageDescriptor> descriptors= input.iterator(); descriptors.hasNext();) {
398		SearchPageDescriptor descriptor= descriptors.next();
	382	for (SearchPageDescriptor descriptor : input) {
399	383	if (!WorkbenchActivityHelper.filterItem(descriptor))
400	384	filteredList.add(descriptor);
401	385

448	432	final CTabItem item = new CTabItem(folder, SWT.NONE);
449	433	item.setData("descriptor", descriptor); //$NON-NLS-1$
450	434	item.setText(descriptor.getLabel());
451		item.addDisposeListener(new DisposeListener() {
452		@Override
453		public void widgetDisposed(DisposeEvent e) {
454		item.setData("descriptor", null); //$NON-NLS-1$
455		if (item.getImage() != null)
456		item.getImage().dispose();
457		}
	435	item.addDisposeListener(e -> {
	436	item.setData("descriptor", null); //$NON-NLS-1$
	437	if (item.getImage() != null)
	438	item.getImage().dispose();
458	439	});
459	440	ImageDescriptor imageDesc= descriptor.getImage();
460	441	if (imageDesc != null)

758	739
759	740	applyDialogFont(pageWrapper);
760	741
761		BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() {
	742	BusyIndicator.showWhile(getShell().getDisplay(), () -> SafeRunner.run(new ISafeRunnable() {
762	743	@Override
763		public void run() {
764		SafeRunner.run(new ISafeRunnable() {
765		@Override
766		public void run() throws Exception {
767		// create page and control
768		ISearchPage page= descriptor.createObject(SearchDialog.this);
769		if (page != null) {
770		page.createControl(pageWrapper);
771		}
772		}
773		@Override
774		public void handleException(Throwable ex) {
775		if (ex instanceof CoreException) {
776		ExceptionHandler.handle((CoreException) ex, getShell(), SearchMessages.Search_Error_createSearchPage_title, Messages.format(SearchMessages.Search_Error_createSearchPage_message, descriptor.getLabel()));
777		} else {
778		ExceptionHandler.displayMessageDialog(ex, getShell(), SearchMessages.Search_Error_createSearchPage_title, Messages.format(SearchMessages.Search_Error_createSearchPage_message, descriptor.getLabel()));
779		}
780		}
781		});
782		}
783		});
	744	public void run() throws Exception {
	745	// create page and control
	746	ISearchPage page= descriptor.createObject(SearchDialog.this);
	747	if (page != null) {
	748	page.createControl(pageWrapper);
	749	}
	750	}
	751	@Override
	752	public void handleException(Throwable ex) {
	753	if (ex instanceof CoreException) {
	754	ExceptionHandler.handle((CoreException) ex, getShell(), SearchMessages.Search_Error_createSearchPage_title, Messages.format(SearchMessages.Search_Error_createSearchPage_message, descriptor.getLabel()));
	755	} else {
	756	ExceptionHandler.displayMessageDialog(ex, getShell(), SearchMessages.Search_Error_createSearchPage_title, Messages.format(SearchMessages.Search_Error_createSearchPage_message, descriptor.getLabel()));
	757	}
	758	}
	759	}));
784	760
785	761	ISearchPage page= descriptor.getPage();
786	762	if (page == null \|\| page.getControl() == null) {

+28

-47

org.eclipse.search/search/org/eclipse/search/internal/ui/SearchManager.java less more

235	235	if (display != null && !display.isDisposed()) {
236	236	final String warningTitle= SearchMessages.SearchManager_resourceChangedWarning;
237	237	final String warningMsg= warningMessage;
238		display.syncExec(new Runnable() {
239		@Override
240		public void run() {
241		MessageDialog.openWarning(getShell(), warningTitle, warningMsg);
242		}
243		});
	238	display.syncExec(() -> MessageDialog.openWarning(getShell(), warningTitle, warningMsg));
244	239	}
245	240	}
246	241

250	245	final Viewer visibleViewer= ((SearchResultView)SearchUI.getSearchResultView()).getViewer();
251	246	while (iter2.hasNext()) {
252	247	final SearchResultViewer viewer= iter2.next();
253		display.syncExec(new Runnable() {
254		@Override
255		public void run() {
256		if (previousSearch != null && viewer == visibleViewer)
257		previousSearch.setSelection(viewer.getSelection());
258		viewer.setInput(null);
259		viewer.setPageId(search.getPageId());
260		viewer.setGotoMarkerAction(search.getGotoMarkerAction());
261		viewer.setContextMenuTarget(search.getContextMenuContributor());
262		viewer.setActionGroupFactory(null);
263		viewer.setInput(getCurrentResults());
264		viewer.setActionGroupFactory(search.getActionGroupFactory());
265		viewer.setSelection(fCurrentSearch.getSelection(), true);
266		}
	248	display.syncExec(() -> {
	249	if (previousSearch != null && viewer == visibleViewer)
	250	previousSearch.setSelection(viewer.getSelection());
	251	viewer.setInput(null);
	252	viewer.setPageId(search.getPageId());
	253	viewer.setGotoMarkerAction(search.getGotoMarkerAction());
	254	viewer.setContextMenuTarget(search.getContextMenuContributor());
	255	viewer.setActionGroupFactory(null);
	256	viewer.setInput(getCurrentResults());
	257	viewer.setActionGroupFactory(search.getActionGroupFactory());
	258	viewer.setSelection(fCurrentSearch.getSelection(), true);
267	259	});
268	260	}
269	261	}

301	293	final Viewer visibleViewer= ((SearchResultView)SearchUI.getSearchResultView()).getViewer();
302	294	while (iter.hasNext()) {
303	295	final SearchResultViewer viewer= iter.next();
304		display.syncExec(new Runnable() {
305		@Override
306		public void run() {
307		if (fCurrentSearch != null && viewer == visibleViewer)
308		fCurrentSearch.setSelection(viewer.getSelection());
309		setNewSearch(viewer, newSearch);
310		}
	296	display.syncExec(() -> {
	297	if (fCurrentSearch != null && viewer == visibleViewer)
	298	fCurrentSearch.setSelection(viewer.getSelection());
	299	setNewSearch(viewer, newSearch);
311	300	});
312	301	}
313	302	}

340	329	if (Thread.currentThread() == display.getThread())
341	330	handleNewSearchResult();
342	331	else {
343		display.syncExec(new Runnable() {
344		@Override
345		public void run() {
346		handleNewSearchResult();
347		}
348		});
	332	display.syncExec(() -> handleNewSearchResult());
349	333	}
350	334	SearchPlugin.getWorkspace().addResourceChangeListener(this);
351	335	}

372	356	while (iter.hasNext())
373	357	iter.next().getControl().setRedraw(false);
374	358
375		for (int i=0; i < markerDeltas.length; i++) {
376		handleSearchMarkerChanged(markerDeltas[i]);
	359	for (IMarkerDelta markerDelta : markerDeltas) {
	360	handleSearchMarkerChanged(markerDelta);
377	361	}
378	362
379	363	iter= fListeners.iterator();

472	456	if (display == null \|\| display.isDisposed())
473	457	return;
474	458
475		Runnable runnable= new Runnable() {
476		@Override
477		public void run() {
478		if (getCurrentSearch() != null) {
479		handleSearchMarkersChanged(markerDeltas);
480		// update title and actions
481		Iterator<SearchResultViewer> iter= fListeners.iterator();
482		while (iter.hasNext()) {
483		SearchResultViewer viewer= iter.next();
484		viewer.enableActions();
485		viewer.updateTitle();
486		}
	459	Runnable runnable= () -> {
	460	if (getCurrentSearch() != null) {
	461	handleSearchMarkersChanged(markerDeltas);
	462	// update title and actions
	463	Iterator<SearchResultViewer> iter= fListeners.iterator();
	464	while (iter.hasNext()) {
	465	SearchResultViewer viewer= iter.next();
	466	viewer.enableActions();
	467	viewer.updateTitle();
487	468	}
488	469	}
489	470	};

+7

-1

org.eclipse.search/search/org/eclipse/search/internal/ui/SearchMessages.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2015 IBM Corporation and others.
	1	* Copyright (c) 2000, 2017 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

8	8	* IBM Corporation - initial API and implementation
9	9	* Christian Walther (Indel AG) - Bug 399094: Add whole word option to file search
10	10	* Marco Descher <marco@descher.at> - Open Search dialog with previous page instead of using the current selection to detect the page - http://bugs.eclipse.org/33710
	11	* Lucas Bullen (Red Hat Inc.) - [Bug 526453] disambiguate "Selected Resources"
11	12	*******************************************************************************/
12	13	package org.eclipse.search.internal.ui;
13	14

172	173	public static String WorkspaceScope;
173	174	public static String ScopePart_group_text;
174	175	public static String ScopePart_selectedResourcesScope_text;
	176	public static String ScopePart_selectedResourcesScope_text_plural;
	177	public static String ScopePart_selectedResourcesScope_text_singular;
	178	public static String ScopePart_selectedResourcesScope_text_editor;
175	179	public static String ScopePart_enclosingProjectsScope_text;
	180	public static String ScopePart_enclosingProjectsScope_text_plural;
	181	public static String ScopePart_enclosingProjectsScope_text_singular;
176	182	public static String ScopePart_workingSetChooseButton_text;
177	183	public static String ScopePart_workingSetText_accessible_label;
178	184	public static String ScopePart_workingSetScope_text;

+7

-1

org.eclipse.search/search/org/eclipse/search/internal/ui/SearchMessages.properties less more

0	0	###############################################################################
1		# Copyright (c) 2000, 2015 IBM Corporation and others.
	1	# Copyright (c) 2000, 2017 IBM Corporation and others.
2	2	# All rights reserved. This program and the accompanying materials
3	3	# are made available under the terms of the Eclipse Public License v1.0
4	4	# which accompanies this distribution, and is available at

8	8	# IBM Corporation - initial API and implementation
9	9	# Christian Walther (Indel AG) - Bug 399094: Add whole word option to file search
10	10	# Marco Descher <marco@descher.at> - Open Search dialog with previous page instead of using the current selection to detect the page - http://bugs.eclipse.org/33710
	11	# Lucas Bullen (Red Hat Inc.) - [Bug 526453] disambiguate "Selected Resources"
11	12	###############################################################################
12	13
13	14	SearchDialog_title= Search

180	181
181	182	ScopePart_group_text= Scope
182	183	ScopePart_selectedResourcesScope_text=Selecte&d resources
	184	ScopePart_selectedResourcesScope_text_plural={0} selecte&d resources in ''{1}''
	185	ScopePart_selectedResourcesScope_text_singular=Selecte&d resource in ''{0}''
	186	ScopePart_selectedResourcesScope_text_editor=Resource in active e&ditor
183	187	ScopePart_enclosingProjectsScope_text=Enclosing pro&jects
	188	ScopePart_enclosingProjectsScope_text_plural={0} enclosing pro&jects
	189	ScopePart_enclosingProjectsScope_text_singular=Enclosing pro&ject
184	190	ScopePart_workingSetChooseButton_text= C&hoose...
185	191	ScopePart_workingSetText_accessible_label=Working set name
186	192	ScopePart_workingSetScope_text=Wor&king set:

+3

-3

org.eclipse.search/search/org/eclipse/search/internal/ui/SearchPageDescriptor.java less more

232	232
233	233	static void setEnabled(Object[] enabledDescriptors) {
234	234	fgEnabledPageIds= new ArrayList<>(5);
235		for (int i= 0; i < enabledDescriptors.length; i++) {
236		if (enabledDescriptors[i] instanceof SearchPageDescriptor)
237		fgEnabledPageIds.add(((SearchPageDescriptor)enabledDescriptors[i]).getId());
	235	for (Object enabledDescriptor : enabledDescriptors) {
	236	if (enabledDescriptor instanceof SearchPageDescriptor)
	237	fgEnabledPageIds.add(((SearchPageDescriptor)enabledDescriptor).getId());
238	238	}
239	239	storeEnabledPageIds();
240	240	}

+5

-12

org.eclipse.search/search/org/eclipse/search/internal/ui/SearchPlugin.java less more

112	112	IWorkbenchWindow window= fgSearchPlugin.getWorkbench().getActiveWorkbenchWindow();
113	113	if (window == null) {
114	114	final WindowRef windowRef= new WindowRef();
115		Display.getDefault().syncExec(new Runnable() {
116		@Override
117		public void run() {
118		setActiveWorkbenchWindow(windowRef);
119		}
120		});
	115	Display.getDefault().syncExec(() -> setActiveWorkbenchWindow(windowRef));
121	116	return windowRef.window;
122	117	}
123	118	return window;

142	137	shell= shell.getParent();
143	138	}
144	139	Shell shells[]= display.getShells();
145		for (int i= 0; i < shells.length; i++) {
146		Object data= shells[i].getData();
	140	for (Shell shell2 : shells) {
	141	Object data= shell2.getData();
147	142	if (data instanceof IWorkbenchWindow) {
148	143	windowRef.window= (IWorkbenchWindow)data;
149	144	return;

281	276	*/
282	277	private List<SearchPageDescriptor> createSearchPageDescriptors(IConfigurationElement[] elements) {
283	278	List<SearchPageDescriptor> result= new ArrayList<>(5);
284		for (int i= 0; i < elements.length; i++) {
285		IConfigurationElement element= elements[i];
	279	for (IConfigurationElement element : elements) {
286	280	if (SearchPageDescriptor.PAGE_TAG.equals(element.getName())) {
287	281	SearchPageDescriptor desc= new SearchPageDescriptor(element);
288	282	result.add(desc);

325	319	*/
326	320	private List<SorterDescriptor> createSorterDescriptors(IConfigurationElement[] elements) {
327	321	List<SorterDescriptor> result= new ArrayList<>(5);
328		for (int i= 0; i < elements.length; i++) {
329		IConfigurationElement element= elements[i];
	322	for (IConfigurationElement element : elements) {
330	323	if (SorterDescriptor.SORTER_TAG.equals(element.getName()))
331	324	result.add(new SorterDescriptor(element));
332	325	}

+1

-1

org.eclipse.search/search/org/eclipse/search/internal/ui/SearchResultLabelProvider.java less more

36	36
37	37	@Override
38	38	public String getText(Object element) {
39		StringBuffer buf= new StringBuffer(getLabelProvider().getText(element));
	39	StringBuilder buf= new StringBuilder(getLabelProvider().getText(element));
40	40	int count= ((ISearchResultViewEntry)element).getMatchCount();
41	41	if (count > 1) {
42	42	buf.append(" ("); //$NON-NLS-1$

+5

-14

org.eclipse.search/search/org/eclipse/search/internal/ui/SearchResultView.java less more

30	30	import org.eclipse.jface.operation.IRunnableWithProgress;
31	31	import org.eclipse.jface.resource.ImageDescriptor;
32	32	import org.eclipse.jface.util.IPropertyChangeListener;
33		import org.eclipse.jface.util.PropertyChangeEvent;
34	33	import org.eclipse.jface.viewers.IBaseLabelProvider;
35	34	import org.eclipse.jface.viewers.ILabelProvider;
36	35	import org.eclipse.jface.viewers.ISelection;

110	109
111	110	fillActionBars(getViewSite().getActionBars());
112	111
113		fPropertyChangeListener= new IPropertyChangeListener() {
114		@Override
115		public void propertyChange(PropertyChangeEvent event) {
116		if (SearchPreferencePage.POTENTIAL_MATCH_FG_COLOR.equals(event.getProperty()) \|\| SearchPreferencePage.EMPHASIZE_POTENTIAL_MATCHES.equals(event.getProperty()))
117		if (fViewer != null)
118		fViewer.updatedPotentialMatchFgColor();
119		}
	112	fPropertyChangeListener= event -> {
	113	if (SearchPreferencePage.POTENTIAL_MATCH_FG_COLOR.equals(event.getProperty()) \|\| SearchPreferencePage.EMPHASIZE_POTENTIAL_MATCHES.equals(event.getProperty()))
	114	if (fViewer != null)
	115	fViewer.updatedPotentialMatchFgColor();
120	116	};
121	117
122	118	SearchPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(fPropertyChangeListener);

199	195
200	196	private void setGotoMarkerAction(final IAction gotoMarkerAction) {
201	197	// Make sure we are doing it in the right thread.
202		getDisplay().syncExec(new Runnable() {
203		@Override
204		public void run() {
205		getViewer().setGotoMarkerAction(gotoMarkerAction);
206		}
207		});
	198	getDisplay().syncExec(() -> getViewer().setGotoMarkerAction(gotoMarkerAction));
208	199	}
209	200
210	201

+9

-26

org.eclipse.search/search/org/eclipse/search/internal/ui/SearchResultViewer.java less more

37	37	import org.eclipse.core.resources.IResource;
38	38
39	39	import org.eclipse.jface.action.IAction;
40		import org.eclipse.jface.action.IMenuListener;
41	40	import org.eclipse.jface.action.IMenuManager;
42	41	import org.eclipse.jface.action.IToolBarManager;
43	42	import org.eclipse.jface.action.MenuManager;

45	44	import org.eclipse.jface.viewers.ArrayContentProvider;
46	45	import org.eclipse.jface.viewers.IBaseLabelProvider;
47	46	import org.eclipse.jface.viewers.ILabelProvider;
48		import org.eclipse.jface.viewers.IOpenListener;
49	47	import org.eclipse.jface.viewers.ISelection;
50		import org.eclipse.jface.viewers.ISelectionChangedListener;
51	48	import org.eclipse.jface.viewers.IStructuredSelection;
52	49	import org.eclipse.jface.viewers.LabelProviderChangedEvent;
53		import org.eclipse.jface.viewers.OpenEvent;
54		import org.eclipse.jface.viewers.SelectionChangedEvent;
55	50	import org.eclipse.jface.viewers.StructuredSelection;
56	51	import org.eclipse.jface.viewers.TableViewer;
57	52

143	138	fCopyToClipboardAction= new CopyToClipboardAction(this);
144	139
145	140	addSelectionChangedListener(
146		new ISelectionChangedListener() {
147		@Override
148		public void selectionChanged(SelectionChangedEvent event) {
149		if (fLastSelection == null \|\| !fLastSelection.equals(event.getSelection())) {
150		fLastSelection= event.getSelection();
151		handleSelectionChanged();
152		}
	141	event -> {
	142	if (fLastSelection == null \|\| !fLastSelection.equals(event.getSelection())) {
	143	fLastSelection= event.getSelection();
	144	handleSelectionChanged();
153	145	}
154	146	}
155	147	);
156	148
157		addOpenListener(new IOpenListener() {
158		@Override
159		public void open(OpenEvent event) {
160		showResult();
161		}
162		});
	149	addOpenListener(event -> showResult());
163	150
164	151	MenuManager menuMgr= new MenuManager("#PopUp"); //$NON-NLS-1$
165	152	menuMgr.setRemoveAllWhenShown(true);
166	153	menuMgr.addMenuListener(
167		new IMenuListener() {
168		@Override
169		public void menuAboutToShow(IMenuManager mgr) {
170		SearchPlugin.createStandardGroups(mgr);
171		fillContextMenu(mgr);
172		}
	154	mgr -> {
	155	SearchPlugin.createStandardGroups(mgr);
	156	fillContextMenu(mgr);
173	157	});
174	158	Menu menu= menuMgr.createContextMenu(getTable());
175	159	getTable().setMenu(menu);

677	661	Object[] changed= event.getElements();
678	662	if (changed != null && !fResourceToItemsMapper.isEmpty()) {
679	663	ArrayList<Object> others= new ArrayList<>(changed.length);
680		for (int i= 0; i < changed.length; i++) {
681		Object curr= changed[i];
	664	for (Object curr : changed) {
682	665	if (curr instanceof IResource)
683	666	fResourceToItemsMapper.resourceChanged((IResource) curr);
684	667	else if (curr instanceof IAdaptable) {

+1

-2

org.eclipse.search/search/org/eclipse/search/internal/ui/SelectAllAction.java less more

44	44	}
45	45
46	46	private void collectExpandedAndVisible(TreeItem[] items, List<TreeItem> result) {
47		for (int i= 0; i < items.length; i++) {
48		TreeItem item= items[i];
	47	for (TreeItem item : items) {
49	48	result.add(item);
50	49	if (item.getExpanded()) {
51	50	collectExpandedAndVisible(item.getItems(), result);

+4

-9

org.eclipse.search/search/org/eclipse/search/internal/ui/SortDropDownAction.java less more

109	109	public void run() {
110	110	if (!checkedId.equals(sorterDesc.getId())) {
111	111	SortDropDownAction.this.setChecked(sorterDesc);
112		BusyIndicator.showWhile(parent.getDisplay(), new Runnable() {
113		@Override
114		public void run() {
115		fViewer.setSorter(sorter);
116		}
117		});
	112	BusyIndicator.showWhile(parent.getDisplay(), () -> fViewer.setSorter(sorter));
118	113	}
119	114	}
120	115	};

189	184	if (memento == null)
190	185	return;
191	186	IMemento[] mementoElements= memento.getChildren(TAG_ELEMENT);
192		for (int i= 0; i < mementoElements.length; i++) {
193		String pageId= mementoElements[i].getString(TAG_PAGE_ID);
194		String sorterId= mementoElements[i].getString(TAG_SORTER_ID);
	187	for (IMemento mementoElement : mementoElements) {
	188	String pageId= mementoElement.getString(TAG_PAGE_ID);
	189	String sorterId= mementoElement.getString(TAG_SORTER_ID);
195	190	SorterDescriptor sorterDesc= getSorter(sorterId);
196	191	if (sorterDesc != null)
197	192	map.put(pageId, sorterDesc);

+1

-6

org.eclipse.search/search/org/eclipse/search/internal/ui/text/DecoratingFileSearchLabelProvider.java less more

89	89	String property= event.getProperty();
90	90	if (property.equals(JFacePreferences.QUALIFIER_COLOR) \|\| property.equals(JFacePreferences.COUNTER_COLOR) \|\| property.equals(JFacePreferences.DECORATIONS_COLOR)
91	91	\|\| property.equals(HIGHLIGHT_BG_COLOR_NAME) \|\| property.equals(IWorkbenchPreferenceConstants.USE_COLORED_LABELS)) {
92		Display.getDefault().asyncExec(new Runnable() {
93		@Override
94		public void run() {
95		refresh();
96		}
97		});
	92	Display.getDefault().asyncExec(() -> refresh());
98	93	}
99	94	}
100	95

+2

-2

org.eclipse.search/search/org/eclipse/search/internal/ui/text/EditorOpener.java less more

45	45
46	46	public IEditorPart openAndSelect(IWorkbenchPage wbPage, IFile file, int offset, int length, boolean activate) throws PartInitException {
47	47	String editorId= null;
48		IEditorDescriptor desc= IDE.getEditorDescriptor(file);
	48	IEditorDescriptor desc = IDE.getEditorDescriptor(file, true, true);
49	49	if (desc == null \|\| !desc.isInternal()) {
50	50	editorId= "org.eclipse.ui.DefaultTextEditor"; //$NON-NLS-1$
51	51	} else {

74	74
75	75
76	76	private String getEditorID(IFile file) throws PartInitException {
77		IEditorDescriptor desc= IDE.getEditorDescriptor(file);
	77	IEditorDescriptor desc = IDE.getEditorDescriptor(file, true, true);
78	78	if (desc == null)
79	79	return SearchPlugin.getDefault().getWorkbench().getEditorRegistry().findEditor(IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID).getId();
80	80	return desc.getId();

+1

-6

org.eclipse.search/search/org/eclipse/search/internal/ui/text/FileLabelProvider.java less more

58	58	fOrder= orderFlag;
59	59	fPage= page;
60	60	fLineMatchImage= SearchPluginImages.get(SearchPluginImages.IMG_OBJ_TEXT_SEARCH_LINE);
61		fMatchComparator= new Comparator<FileMatch>() {
62		@Override
63		public int compare(FileMatch o1, FileMatch o2) {
64		return o1.getOriginalOffset() - o2.getOriginalOffset();
65		}
66		};
	61	fMatchComparator= (o1, o2) -> o1.getOriginalOffset() - o2.getOriginalOffset();
67	62	}
68	63
69	64	public void setOrder(int orderFlag) {

+6

-16

org.eclipse.search/search/org/eclipse/search/internal/ui/text/FileSearchPage.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2015 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

125	125
126	126
127	127	private static final String[] SHOW_IN_TARGETS= new String[] { IPageLayout.ID_RES_NAV };
128		private static final IShowInTargetList SHOW_IN_TARGET_LIST= new IShowInTargetList() {
129		@Override
130		public String[] getShowInTargetIds() {
131		return SHOW_IN_TARGETS;
132		}
133		};
	128	private static final IShowInTargetList SHOW_IN_TARGET_LIST= () -> SHOW_IN_TARGETS;
134	129
135	130	public FileSearchPage() {
136	131	fSortByNameAction= new SortAction(SearchMessages.FileSearchPage_sort_name_label, this, FileLabelProvider.SHOW_LABEL_PATH);

272	267	fActionGroup.fillContextMenu(mgr);
273	268	FileSearchQuery query= (FileSearchQuery) getInput().getQuery();
274	269	if (query.getSearchString().length() > 0) {
275		IStructuredSelection selection= (IStructuredSelection) getViewer().getSelection();
	270	IStructuredSelection selection = getViewer().getStructuredSelection();
276	271	if (!selection.isEmpty()) {
277	272	ReplaceAction replaceSelection= new ReplaceAction(getSite().getShell(), (FileSearchResult)getInput(), selection.toArray());
278	273	replaceSelection.setText(SearchMessages.ReplaceAction_label_selected);

392	387	newSelection.add(element);
393	388	}
394	389
395		return (T) new IShowInSource() {
396		@Override
397		public ShowInContext getShowInContext() {
398		return new ShowInContext(null, new StructuredSelection(new ArrayList<>(newSelection)));
399		}
400		};
	390	return (T) (IShowInSource) () -> new ShowInContext(null, new StructuredSelection(new ArrayList<>(newSelection)));
401	391	}
402	392	return null;
403	393	}

458	448	@Override
459	449	protected void evaluateChangedElements(Match[] matches, Set<Object> changedElements) {
460	450	if (showLineMatches()) {
461		for (int i = 0; i < matches.length; i++) {
462		changedElements.add(((FileMatch) matches[i]).getLineElement());
	451	for (Match match : matches) {
	452	changedElements.add(((FileMatch) match).getLineElement());
463	453	}
464	454	} else {
465	455	super.evaluateChangedElements(matches, changedElements);

+3

-3

org.eclipse.search/search/org/eclipse/search/internal/ui/text/FileSearchQuery.java less more

173	173	}
174	174
175	175	private static String getContents(TextSearchMatchAccess matchRequestor, int start, int end) {
176		StringBuffer buf= new StringBuffer();
	176	StringBuilder buf= new StringBuilder();
177	177	for (int i= start; i < end; i++) {
178	178	char ch= matchRequestor.getFileContentChar(i);
179	179	if (Character.isWhitespace(ch) \|\| Character.isISOControl(ch)) {

258	258	String[] fileNamePatterns= fScope.getFileNamePatterns();
259	259	if (fileNamePatterns == null)
260	260	return true;
261		for (int i= 0; i < fileNamePatterns.length; i++) {
262		if ("*".equals(fileNamePatterns[i])) { //$NON-NLS-1$
	261	for (String fileNamePattern : fileNamePatterns) {
	262	if ("*".equals(fileNamePattern)) { //$NON-NLS-1$
263	263	return true;
264	264	}
265	265	}

+6

-6

org.eclipse.search/search/org/eclipse/search/internal/ui/text/FileTableContentProvider.java less more

58	58	TableViewer viewer= getViewer();
59	59	int elementLimit= getElementLimit();
60	60	boolean tableLimited= elementLimit != -1;
61		for (int i= 0; i < updatedElements.length; i++) {
62		if (fResult.getMatchCount(updatedElements[i]) > 0) {
63		if (viewer.testFindItem(updatedElements[i]) != null)
64		viewer.update(updatedElements[i], null);
	61	for (Object updatedElement : updatedElements) {
	62	if (fResult.getMatchCount(updatedElement) > 0) {
	63	if (viewer.testFindItem(updatedElement) != null)
	64	viewer.update(updatedElement, null);
65	65	else {
66	66	if (!tableLimited \|\| viewer.getTable().getItemCount() < elementLimit)
67		viewer.add(updatedElements[i]);
	67	viewer.add(updatedElement);
68	68	}
69	69	} else
70		viewer.remove(updatedElements[i]);
	70	viewer.remove(updatedElement);
71	71	}
72	72	}
73	73

+5

-5

org.eclipse.search/search/org/eclipse/search/internal/ui/text/FileTreeContentProvider.java less more

77	77
78	78	if (result != null) {
79	79	Object[] elements= result.getElements();
80		for (int i= 0; i < elements.length; i++) {
	80	for (Object element : elements) {
81	81	if (showLineMatches) {
82		Match[] matches= result.getMatches(elements[i]);
83		for (int j= 0; j < matches.length; j++) {
84		insert(((FileMatch) matches[j]).getLineElement(), false);
	82	Match[] matches= result.getMatches(element);
	83	for (Match match : matches) {
	84	insert(((FileMatch) match).getLineElement(), false);
85	85	}
86	86	} else {
87		insert(elements[i], false);
	87	insert(element, false);
88	88	}
89	89	}
90	90	}

+4

-4

org.eclipse.search/search/org/eclipse/search/internal/ui/text/LineElement.java less more

63	63	public FileMatch[] getMatches(AbstractTextSearchResult result) {
64	64	ArrayList<FileMatch> res= new ArrayList<>();
65	65	Match[] matches= result.getMatches(fParent);
66		for (int i= 0; i < matches.length; i++) {
67		FileMatch curr= (FileMatch) matches[i];
	66	for (Match match : matches) {
	67	FileMatch curr= (FileMatch) match;
68	68	if (curr.getLineElement() == this) {
69	69	res.add(curr);
70	70	}

75	75	public int getNumberOfMatches(AbstractTextSearchResult result) {
76	76	int count= 0;
77	77	Match[] matches= result.getMatches(fParent);
78		for (int i= 0; i < matches.length; i++) {
79		FileMatch curr= (FileMatch) matches[i];
	78	for (Match match : matches) {
	79	FileMatch curr= (FileMatch) match;
80	80	if (curr.getLineElement() == this) {
81	81	count++;
82	82	}

+1

-8

org.eclipse.search/search/org/eclipse/search/internal/ui/text/ReplaceConfigurationPage.java less more

13	13	import java.util.regex.PatternSyntaxException;
14	14
15	15	import org.eclipse.swt.SWT;
16		import org.eclipse.swt.events.ModifyEvent;
17		import org.eclipse.swt.events.ModifyListener;
18	16	import org.eclipse.swt.events.SelectionAdapter;
19	17	import org.eclipse.swt.events.SelectionEvent;
20	18	import org.eclipse.swt.layout.GridData;

102	100	gd.widthHint= convertWidthInCharsToPixels(50);
103	101	fTextField.setLayoutData(gd);
104	102	fTextField.setFocus();
105		fTextField.addModifyListener(new ModifyListener() {
106		@Override
107		public void modifyText(ModifyEvent e) {
108		updateOKStatus();
109		}
110		});
	103	fTextField.addModifyListener(e -> updateOKStatus());
111	104
112	105	IDialogSettings settings= SearchPlugin.getDefault().getDialogSettings().getSection(SETTINGS_GROUP);
113	106	if (settings != null) {

+27

-34

org.eclipse.search/search/org/eclipse/search/internal/ui/text/ReplaceRefactoring.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2007, 2015 IBM Corporation and others.
	1	* Copyright (c) 2007, 2017 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

6	6	*
7	7	* Contributors:
8	8	* IBM Corporation - initial API and implementation
	9	* Florian Ingerl <imelflorianingerl@gmail.com> - Bug 109481 - [find/replace] replace doesn't work when using a regex with a lookahead or boundary matchers
9	10	*******************************************************************************/
10	11	package org.eclipse.search.internal.ui.text;
11	12

16	17	import java.util.Comparator;
17	18	import java.util.HashMap;
18	19	import java.util.HashSet;
19		import java.util.Iterator;
20	20	import java.util.Map;
21	21	import java.util.Set;
22	22	import java.util.regex.Matcher;

125	125	private Match[] getMatches() {
126	126	if (fMatches == null) {
127	127	ArrayList<FileMatch> matches= new ArrayList<>();
128		for (int i= 0; i < fMatchGroups.length; i++) {
129		MatchGroup curr= fMatchGroups[i];
	128	for (MatchGroup curr : fMatchGroups) {
130	129	if (curr.group.isEnabled()) {
131	130	FileMatch match= curr.match;
132	131	matches.add(match);

210	209	fMatches.clear();
211	210
212	211	if (fSelection != null) {
213		for (int i= 0; i < fSelection.length; i++) {
214		collectMatches(fSelection[i]);
	212	for (Object element : fSelection) {
	213	collectMatches(element);
215	214	}
216	215	} else {
217	216	Object[] elements= fResult.getElements();
218		for (int i= 0; i < elements.length; i++) {
219		collectMatches(elements[i]);
	217	for (Object element : elements) {
	218	collectMatches(element);
220	219	}
221	220	}
222	221	if (!hasMatches()) {

229	228	if (object instanceof LineElement) {
230	229	LineElement lineElement= (LineElement) object;
231	230	FileMatch[] matches= lineElement.getMatches(fResult);
232		for (int i= 0; i < matches.length; i++) {
233		FileMatch fileMatch= matches[i];
	231	for (FileMatch fileMatch : matches) {
234	232	if (isMatchToBeIncluded(fileMatch)) {
235	233	getBucket(fileMatch.getFile()).add(fileMatch);
236	234	}

238	236	} else if (object instanceof IContainer) {
239	237	IContainer container= (IContainer) object;
240	238	IResource[] members= container.members();
241		for (int i= 0; i < members.length; i++) {
242		collectMatches(members[i]);
	239	for (IResource member : members) {
	240	collectMatches(member);
243	241	}
244	242	} else if (object instanceof IFile) {
245	243	Match[] matches= fResult.getMatches(object);
246	244	if (matches.length > 0) {
247	245	Collection<FileMatch> bucket= null;
248		for (int i= 0; i < matches.length; i++) {
249		FileMatch fileMatch= (FileMatch) matches[i];
	246	for (Match match : matches) {
	247	FileMatch fileMatch= (FileMatch) match;
250	248	if (isMatchToBeIncluded(fileMatch)) {
251	249	if (bucket == null) {
252	250	bucket= getBucket((IFile)object);

264	262
265	263	public int getNumberOfMatches() {
266	264	int count= 0;
267		for (Iterator<Set<FileMatch>> iterator= fMatches.values().iterator(); iterator.hasNext();) {
268		Set<FileMatch> bucket= iterator.next();
	265	for (Set<FileMatch> bucket : fMatches.values()) {
269	266	count += bucket.size();
270	267	}
271	268	return count;

289	286	if (uri == null)
290	287	return true;
291	288
292		for (Iterator<URI> iter= fAlreadyCollected.keySet().iterator(); iter.hasNext();) {
293		if (URIUtil.equals(iter.next(), uri)) {
	289	for (URI uri2 : fAlreadyCollected.keySet()) {
	290	if (URIUtil.equals(uri2, uri)) {
294	291	if (file.equals(fAlreadyCollected.get(uri)))
295	292	return true; // another FileMatch for an IFile which already had matches
296	293

357	354	ArrayList<MatchGroup> matchGroups= new ArrayList<>();
358	355	boolean hasChanges= false;
359	356	try {
360		for (int i= 0; i < allFiles.length; i++) {
361		IFile file= allFiles[i];
	357	for (IFile file : allFiles) {
362	358	Set<FileMatch> bucket= fMatches.get(file);
363	359	if (!bucket.isEmpty()) {
364	360	try {

389	385
390	386	private void checkFilesToBeChanged(IFile[] filesToBeChanged, RefactoringStatus resultingStatus) throws CoreException {
391	387	ArrayList<IFile> readOnly= new ArrayList<>();
392		for (int i= 0; i < filesToBeChanged.length; i++) {
393		IFile file= filesToBeChanged[i];
	388	for (IFile file : filesToBeChanged) {
394	389	if (file.isReadOnly())
395	390	readOnly.add(file);
396	391	}

424	419	IDocument document= textFileBuffer.getDocument();
425	420	String lineDelimiter= TextUtilities.getDefaultLineDelimiter(document);
426	421
427		for (Iterator<FileMatch> iterator= matches.iterator(); iterator.hasNext();) {
428		FileMatch match= iterator.next();
	422	for (FileMatch match : matches) {
429	423	int offset= match.getOffset();
430	424	int length= match.getLength();
431	425	Position currentPosition= tracker.getCurrentPosition(match);

443	437	continue;
444	438	}
445	439
446		String replacementString= computeReplacementString(pattern, originalText, fReplaceString, lineDelimiter);
	440	String replacementString= PatternConstructor.interpretReplaceEscapes(fReplaceString, originalText,
	441	lineDelimiter);
	442	replacementString= computeReplacementString(pattern, document, offset, replacementString);
447	443	if (replacementString == null) {
448	444	resultingStatus.addError(Messages.format(SearchMessages.ReplaceRefactoring_error_match_content_changed, file.getName()));
449	445	continue;

473	469	return PatternConstructor.createPattern(query.getSearchString(), true, true, query.isCaseSensitive(), false);
474	470	}
475	471
476		private String computeReplacementString(Pattern pattern, String originalText, String replacementText, String lineDelimiter) throws PatternSyntaxException {
	472	private String computeReplacementString(Pattern pattern, IDocument document, int offset, String replacementText)
	473	throws PatternSyntaxException {
477	474	if (pattern != null) {
478	475	try {
479		replacementText= PatternConstructor.interpretReplaceEscapes(replacementText, originalText, lineDelimiter);
480
481		Matcher matcher= pattern.matcher(originalText);
482		StringBuffer sb = new StringBuffer();
483		matcher.reset();
484		if (matcher.find()) {
	476	Matcher matcher= pattern.matcher(document.get());
	477	if (matcher.find(offset)) {
	478	StringBuffer sb= new StringBuffer();
485	479	matcher.appendReplacement(sb, replacementText);
	480	return sb.substring(offset);
486	481	} else {
487	482	return null;
488	483	}
489		matcher.appendTail(sb);
490		return sb.toString();
491	484	} catch (IndexOutOfBoundsException ex) {
492	485	throw new PatternSyntaxException(ex.getLocalizedMessage(), replacementText, -1);
493	486	}

+15

-19

org.eclipse.search/search/org/eclipse/search/internal/ui/text/SearchResultUpdater.java less more

16	16	import org.eclipse.core.resources.IResourceChangeEvent;
17	17	import org.eclipse.core.resources.IResourceChangeListener;
18	18	import org.eclipse.core.resources.IResourceDelta;
19		import org.eclipse.core.resources.IResourceDeltaVisitor;
20	19	import org.eclipse.core.resources.ResourcesPlugin;
21	20
22	21	import org.eclipse.search.internal.ui.SearchPlugin;

44	43
45	44	private void handleDelta(IResourceDelta d) {
46	45	try {
47		d.accept(new IResourceDeltaVisitor() {
48		@Override
49		public boolean visit(IResourceDelta delta) throws CoreException {
50		switch (delta.getKind()) {
51		case IResourceDelta.ADDED :
52		return false;
53		case IResourceDelta.REMOVED :
54		IResource res= delta.getResource();
55		if (res instanceof IFile) {
56		Match[] matches= fResult.getMatches(res);
57		fResult.removeMatches(matches);
58		}
59		break;
60		case IResourceDelta.CHANGED :
61		// handle changed resource
62		break;
63		}
64		return true;
	46	d.accept(delta -> {
	47	switch (delta.getKind()) {
	48	case IResourceDelta.ADDED :
	49	return false;
	50	case IResourceDelta.REMOVED :
	51	IResource res= delta.getResource();
	52	if (res instanceof IFile) {
	53	Match[] matches= fResult.getMatches(res);
	54	fResult.removeMatches(matches);
	55	}
	56	break;
	57	case IResourceDelta.CHANGED :
	58	// handle changed resource
	59	break;
65	60	}
	61	return true;
66	62	});
67	63	} catch (CoreException e) {
68	64	SearchPlugin.log(e);

+14

-64

org.eclipse.search/search/org/eclipse/search/internal/ui/text/TextSearchPage.java less more

18	18	import java.io.StringReader;
19	19	import java.util.ArrayList;
20	20	import java.util.HashSet;
21		import java.util.Iterator;
22	21	import java.util.LinkedHashSet;
23	22	import java.util.List;
24	23	import java.util.Set;

26	25
27	26	import org.eclipse.swt.SWT;
28	27	import org.eclipse.swt.custom.CLabel;
29		import org.eclipse.swt.events.ModifyEvent;
30		import org.eclipse.swt.events.ModifyListener;
31	28	import org.eclipse.swt.events.SelectionAdapter;
32	29	import org.eclipse.swt.events.SelectionEvent;
33	30	import org.eclipse.swt.layout.GridData;

41	38
42	39	import org.eclipse.core.runtime.Assert;
43	40	import org.eclipse.core.runtime.CoreException;
44		import org.eclipse.core.runtime.IAdaptable;
45	41	import org.eclipse.core.runtime.IStatus;
46	42
47	43	import org.eclipse.core.resources.IFile;

56	52	import org.eclipse.jface.fieldassist.ComboContentAdapter;
57	53	import org.eclipse.jface.resource.JFaceColors;
58	54	import org.eclipse.jface.viewers.ISelection;
59		import org.eclipse.jface.viewers.IStructuredSelection;
60	55
61	56	import org.eclipse.jface.text.FindReplaceDocumentAdapter;
62	57	import org.eclipse.jface.text.FindReplaceDocumentAdapterContentProposalProvider;

74	69
75	70	import org.eclipse.search.internal.core.text.PatternConstructor;
76	71	import org.eclipse.search.internal.ui.ISearchHelpContextIds;
	72	import org.eclipse.search.internal.ui.ScopePart;
77	73	import org.eclipse.search.internal.ui.SearchMessages;
78	74	import org.eclipse.search.internal.ui.SearchPlugin;
79	75	import org.eclipse.search.internal.ui.util.FileTypeEditor;

293	289	ErrorDialog.openError(getShell(), SearchMessages.TextSearchPage_replace_searchproblems_title, SearchMessages.TextSearchPage_replace_runproblem_message, status);
294	290	}
295	291
296		Display.getCurrent().asyncExec(new Runnable() {
297		@Override
298		public void run() {
299		ISearchResultViewPart view= NewSearchUI.activateSearchResultView();
300		if (view != null) {
301		ISearchResultPage page= view.getActivePage();
302		if (page instanceof FileSearchPage) {
303		FileSearchPage filePage= (FileSearchPage) page;
304		new ReplaceAction(filePage.getSite().getShell(), (FileSearchResult)filePage.getInput(), null).run();
305		}
	292	Display.getCurrent().asyncExec(() -> {
	293	ISearchResultViewPart view= NewSearchUI.activateSearchResultView();
	294	if (view != null) {
	295	ISearchResultPage page= view.getActivePage();
	296	if (page instanceof FileSearchPage) {
	297	FileSearchPage filePage= (FileSearchPage) page;
	298	new ReplaceAction(filePage.getSite().getShell(), (FileSearchResult)filePage.getInput(), null).run();
306	299	}
307	300	}
308	301	});

336	329	}
337	330
338	331	private FileTextSearchScope getSelectedResourcesScope() {
339		HashSet<IResource> resources= new HashSet<>();
340		ISelection sel= getContainer().getSelection();
341		if (sel instanceof IStructuredSelection && !sel.isEmpty()) {
342		Iterator<?> iter= ((IStructuredSelection) sel).iterator();
343		while (iter.hasNext()) {
344		Object curr= iter.next();
345		if (curr instanceof IWorkingSet) {
346		IWorkingSet workingSet= (IWorkingSet) curr;
347		if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
348		return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
349		}
350		IAdaptable[] elements= workingSet.getElements();
351		for (int i= 0; i < elements.length; i++) {
352		IResource resource= elements[i].getAdapter(IResource.class);
353		if (resource != null && resource.isAccessible()) {
354		resources.add(resource);
355		}
356		}
357		} else if (curr instanceof LineElement) {
358		IResource resource= ((LineElement)curr).getParent();
359		if (resource != null && resource.isAccessible())
360		resources.add(resource);
361		} else if (curr instanceof IAdaptable) {
362		IResource resource= ((IAdaptable)curr).getAdapter(IResource.class);
363		if (resource != null && resource.isAccessible()) {
364		resources.add(resource);
365		}
366		}
367		}
368		} else if (getContainer().getActiveEditorInput() != null) {
369		resources.add(getContainer().getActiveEditorInput().getAdapter(IFile.class));
370		}
371		IResource[] arr= resources.toArray(new IResource[resources.size()]);
	332	IResource[] arr = ScopePart.selectedResourcesFromContainer(getContainer()).toArray(new IResource[0]);
372	333	return FileTextSearchScope.newSearchScope(arr, getExtensions(), fSearchDerived);
373	334	}
374	335

389	350
390	351
391	352	private SearchPatternData findInPrevious(String pattern) {
392		for (Iterator<SearchPatternData> iter= fPreviousSearchPatterns.iterator(); iter.hasNext();) {
393		SearchPatternData element= iter.next();
	353	for (SearchPatternData element : fPreviousSearchPatterns) {
394	354	if (pattern.equals(element.textPattern)) {
395	355	return element;
396	356	}

552	512	}
553	513	});
554	514	// add some listeners for regex syntax checking
555		fPattern.addModifyListener(new ModifyListener() {
556		@Override
557		public void modifyText(ModifyEvent e) {
558		updateOKStatus();
559		}
560		});
	515	fPattern.addModifyListener(e -> updateOKStatus());
561	516	fPattern.setFont(group.getFont());
562	517	GridData data= new GridData(GridData.FILL, GridData.FILL, true, false, 1, 2);
563	518	data.widthHint= convertWidthInCharsToPixels(50);

685	640	private String insertEscapeChars(String text) {
686	641	if (text == null \|\| text.equals("")) //$NON-NLS-1$
687	642	return ""; //$NON-NLS-1$
688		StringBuffer sbIn= new StringBuffer(text);
	643	StringBuilder sbIn= new StringBuilder(text);
689	644	BufferedReader reader= new BufferedReader(new StringReader(text));
690	645	int lengthOfFirstLine= 0;
691	646	try {

693	648	} catch (IOException ex) {
694	649	return ""; //$NON-NLS-1$
695	650	}
696		StringBuffer sbOut= new StringBuffer(lengthOfFirstLine + 5);
	651	StringBuilder sbOut= new StringBuilder(lengthOfFirstLine + 5);
697	652	int i= 0;
698	653	while (i < lengthOfFirstLine) {
699	654	char ch= sbIn.charAt(i);

729	684	label.setFont(group.getFont());
730	685
731	686	fExtensions= new Combo(group, SWT.SINGLE \| SWT.BORDER);
732		fExtensions.addModifyListener(new ModifyListener() {
733		@Override
734		public void modifyText(ModifyEvent e) {
735		updateOKStatus();
736		}
737		});
	687	fExtensions.addModifyListener(e -> updateOKStatus());
738	688	GridData data= new GridData(GridData.FILL, GridData.FILL, true, false, 1, 1);
739	689	data.widthHint= convertWidthInCharsToPixels(50);
740	690	fExtensions.setLayoutData(data);

+5

-9

org.eclipse.search/search/org/eclipse/search/internal/ui/util/ExtendedDialogWindow.java less more

13	13	import java.lang.reflect.InvocationTargetException;
14	14	import java.util.ArrayList;
15	15	import java.util.HashMap;
16		import java.util.Iterator;
17	16	import java.util.List;
18	17
19	18	import org.eclipse.swt.SWT;

173	172	* @param state The new state
174	173	*/
175	174	public void setPerformActionEnabled(boolean state) {
176		for (Iterator<Button> buttons = fActionButtons.iterator(); buttons.hasNext(); ) {
177		Button element = buttons.next();
	175	for (Button element : fActionButtons) {
178	176	element.setEnabled(state);
179	177	}
180	178	}

270	268
271	269	private void setDisplayCursor(Display d, Cursor c) {
272	270	Shell[] shells= d.getShells();
273		for (int i= 0; i < shells.length; i++)
274		shells[i].setCursor(c);
	271	for (Shell shell2 : shells)
	272	shell2.setCursor(c);
275	273	}
276	274
277	275	//---- UI state save and restoring ---------------------------------------------
278	276
279	277	private void restoreUIState(HashMap<Object, Object> state) {
280	278	restoreEnableState(fCancelButton, state);
281		for (Iterator<Button> actionButtons = fActionButtons.iterator(); actionButtons.hasNext(); ) {
282		Button button = actionButtons.next();
	279	for (Button button : fActionButtons) {
283	280	restoreEnableState(button, state);
284	281	}
285	282	ControlEnableState pageState= (ControlEnableState)state.get("tabForm"); //$NON-NLS-1$

300	297	private HashMap<Object, Object> saveUIState(boolean keepCancelEnabled) {
301	298	HashMap<Object, Object> savedState= new HashMap<>(10);
302	299	saveEnableStateAndSet(fCancelButton, savedState, keepCancelEnabled);
303		for (Iterator<Button> actionButtons = fActionButtons.iterator(); actionButtons.hasNext(); ) {
304		Button button = actionButtons.next();
	300	for (Button button : fActionButtons) {
305	301	saveEnableStateAndSet(button, savedState, false);
306	302	}
307	303	savedState.put("tabForm", ControlEnableState.disable(fContents)); //$NON-NLS-1$

+9

-12

org.eclipse.search/search/org/eclipse/search/internal/ui/util/FileTypeEditor.java less more

37	37	private final static String TYPE_DELIMITER= SearchMessages.FileTypeEditor_typeDelimiter;
38	38	public final static String FILE_PATTERN_NEGATOR= "!"; //$NON-NLS-1$
39	39
40		private static final Comparator<String> FILE_TYPES_COMPARATOR= new Comparator<String>() {
41		@Override
42		public int compare(String fp1, String fp2) {
43		boolean isNegative1= fp1.startsWith(FILE_PATTERN_NEGATOR);
44		boolean isNegative2= fp2.startsWith(FILE_PATTERN_NEGATOR);
45		if (isNegative1 != isNegative2) {
46		return isNegative1 ? 1 : -1;
47		}
48		return fp1.compareTo(fp2);
	40	private static final Comparator<String> FILE_TYPES_COMPARATOR= (fp1, fp2) -> {
	41	boolean isNegative1= fp1.startsWith(FILE_PATTERN_NEGATOR);
	42	boolean isNegative2= fp2.startsWith(FILE_PATTERN_NEGATOR);
	43	if (isNegative1 != isNegative2) {
	44	return isNegative1 ? 1 : -1;
49	45	}
	46	return fp1.compareTo(fp2);
50	47	};
51	48
52	49	public FileTypeEditor(Combo textField, Button browseButton) {

94	91	Object[] result= dialog.getResult();
95	92	HashSet<String> patterns= new HashSet<>();
96	93	boolean starIncluded= false;
97		for (int i= 0; i < result.length; i++) {
98		String curr= result[i].toString();
	94	for (Object element : result) {
	95	String curr= element.toString();
99	96	if (curr.equals("*")) { //$NON-NLS-1$
100	97	starIncluded= true;
101	98	} else {

113	110
114	111	public static String typesToString(String[] types) {
115	112	Arrays.sort(types, FILE_TYPES_COMPARATOR);
116		StringBuffer result= new StringBuffer();
	113	StringBuilder result= new StringBuilder();
117	114	for (int i= 0; i < types.length; i++) {
118	115	if (i > 0) {
119	116	result.append(TYPE_DELIMITER);

+19

-0

org.eclipse.search.tests/.settings/org.eclipse.jdt.core.prefs less more

132	132	org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
133	133	org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
134	134	org.eclipse.jdt.core.compiler.source=1.8
	135	org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647
135	136	org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
136	137	org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
137	138	org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0

145	146	org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=48
146	147	org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
147	148	org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
	149	org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header=0
148	150	org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
149	151	org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
	152	org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references=0
150	153	org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
151	154	org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
152	155	org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80

156	159	org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
157	160	org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
158	161	org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
	162	org.eclipse.jdt.core.formatter.alignment_for_type_arguments=0
	163	org.eclipse.jdt.core.formatter.alignment_for_type_parameters=0
159	164	org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
160	165	org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
161	166	org.eclipse.jdt.core.formatter.blank_lines_after_package=1

182	187	org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
183	188	org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
184	189	org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
	190	org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position=false
185	191	org.eclipse.jdt.core.formatter.comment.format_block_comments=false
186	192	org.eclipse.jdt.core.formatter.comment.format_header=false
187	193	org.eclipse.jdt.core.formatter.comment.format_html=true

214	220	org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
215	221	org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
216	222	org.eclipse.jdt.core.formatter.indentation.size=4
	223	org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant=insert
217	224	org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert
218	225	org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
219	226	org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert

408	415	org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=true
409	416	org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
410	417	org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=3
	418	org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=common_lines
	419	org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause=common_lines
	420	org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration=common_lines
	421	org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment=common_lines
	422	org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement=common_lines
	423	org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration=common_lines
	424	org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration=common_lines
	425	org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation=common_lines
	426	org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement=common_lines
	427	org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause=common_lines
411	428	org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
412	429	org.eclipse.jdt.core.formatter.tabulation.char=tab
413	430	org.eclipse.jdt.core.formatter.tabulation.size=4
414	431	org.eclipse.jdt.core.formatter.use_on_off_tags=false
415	432	org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
	433	org.eclipse.jdt.core.formatter.wrap_before_assignment_operator=false
416	434	org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
	435	org.eclipse.jdt.core.formatter.wrap_before_conditional_operator=true
417	436	org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
418	437	org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
419	438	org.eclipse.jdt.core.incompatibleJDKLevel=ignore

+59

-1

org.eclipse.search.tests/.settings/org.eclipse.jdt.ui.prefs less more

0	0	eclipse.preferences.version=1
	1	editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
1	2	formatter_profile=_JDT UI Code Style Conventions
2		formatter_settings_version=12
	3	formatter_settings_version=13
3	4	org.eclipse.jdt.ui.exception.name=e
4	5	org.eclipse.jdt.ui.gettersetter.use.is=true
5	6	org.eclipse.jdt.ui.ignorelowercasenames=true

8	9	org.eclipse.jdt.ui.ondemandthreshold=99
9	10	org.eclipse.jdt.ui.overrideannotation=true
10	11	org.eclipse.jdt.ui.staticondemandthreshold=99
	12	sp_cleanup.add_default_serial_version_id=true
	13	sp_cleanup.add_generated_serial_version_id=false
	14	sp_cleanup.add_missing_annotations=true
	15	sp_cleanup.add_missing_deprecated_annotations=true
	16	sp_cleanup.add_missing_methods=false
	17	sp_cleanup.add_missing_nls_tags=false
	18	sp_cleanup.add_missing_override_annotations=true
	19	sp_cleanup.add_missing_override_annotations_interface_methods=true
	20	sp_cleanup.add_serial_version_id=false
	21	sp_cleanup.always_use_blocks=true
	22	sp_cleanup.always_use_parentheses_in_expressions=false
	23	sp_cleanup.always_use_this_for_non_static_field_access=false
	24	sp_cleanup.always_use_this_for_non_static_method_access=false
	25	sp_cleanup.convert_functional_interfaces=false
	26	sp_cleanup.convert_to_enhanced_for_loop=false
	27	sp_cleanup.correct_indentation=false
	28	sp_cleanup.format_source_code=true
	29	sp_cleanup.format_source_code_changes_only=true
	30	sp_cleanup.insert_inferred_type_arguments=false
	31	sp_cleanup.make_local_variable_final=true
	32	sp_cleanup.make_parameters_final=false
	33	sp_cleanup.make_private_fields_final=true
	34	sp_cleanup.make_type_abstract_if_missing_method=false
	35	sp_cleanup.make_variable_declarations_final=false
	36	sp_cleanup.never_use_blocks=false
	37	sp_cleanup.never_use_parentheses_in_expressions=true
	38	sp_cleanup.on_save_use_additional_actions=true
	39	sp_cleanup.organize_imports=true
	40	sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
	41	sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
	42	sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
	43	sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
	44	sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
	45	sp_cleanup.remove_private_constructors=true
	46	sp_cleanup.remove_redundant_type_arguments=false
	47	sp_cleanup.remove_trailing_whitespaces=true
	48	sp_cleanup.remove_trailing_whitespaces_all=true
	49	sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
	50	sp_cleanup.remove_unnecessary_casts=false
	51	sp_cleanup.remove_unnecessary_nls_tags=false
	52	sp_cleanup.remove_unused_imports=false
	53	sp_cleanup.remove_unused_local_variables=false
	54	sp_cleanup.remove_unused_private_fields=true
	55	sp_cleanup.remove_unused_private_members=false
	56	sp_cleanup.remove_unused_private_methods=true
	57	sp_cleanup.remove_unused_private_types=true
	58	sp_cleanup.sort_members=false
	59	sp_cleanup.sort_members_all=false
	60	sp_cleanup.use_anonymous_class_creation=false
	61	sp_cleanup.use_blocks=false
	62	sp_cleanup.use_blocks_only_for_return_and_throw=false
	63	sp_cleanup.use_lambda=true
	64	sp_cleanup.use_parentheses_in_expressions=false
	65	sp_cleanup.use_this_for_non_static_field_access=false
	66	sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true
	67	sp_cleanup.use_this_for_non_static_method_access=false
	68	sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true

+4

-2

org.eclipse.search.tests/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %pluginName
3	3	Bundle-SymbolicName: org.eclipse.search.tests
4		Bundle-Version: 3.9.0.qualifier
	4	Bundle-Version: 3.9.100.qualifier
5	5	Bundle-Activator: org.eclipse.search.tests.SearchTestPlugin
6	6	Bundle-Vendor: %providerName
7	7	Bundle-Localization: plugin

17	17	org.junit;bundle-version="4.12.0",
18	18	org.eclipse.ui.workbench.texteditor;bundle-version="[3.5.0,4.0.0)",
19	19	org.eclipse.jface.text;bundle-version="[3.5.0,4.0.0)",
20		org.eclipse.ui.editors;bundle-version="[3.5.0,4.0.0)"
	20	org.eclipse.ui.editors;bundle-version="[3.5.0,4.0.0)",
	21	org.eclipse.ltk.core.refactoring;bundle-version="[3.5.0,4.0.0)"
21	22	Bundle-ActivationPolicy: lazy
22	23	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
23	24	Eclipse-BundleShape: dir
	25	Automatic-Module-Name: org.eclipse.search.tests

+2

-2

org.eclipse.search.tests/pom.xml less more

13	13	<parent>
14	14	<artifactId>tests-pom</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	<relativePath>../tests-pom/</relativePath>
18	18	</parent>
19	19	<groupId>org.eclipse.search</groupId>
20	20	<artifactId>org.eclipse.search.tests</artifactId>
21		<version>3.9.0-SNAPSHOT</version>
	21	<version>3.9.100-SNAPSHOT</version>
22	22	<packaging>eclipse-test-plugin</packaging>
23	23	<properties>
24	24	<testSuite>${project.artifactId}</testSuite>

+5

-5

org.eclipse.search.tests/src/org/eclipse/search/core/tests/LineConversionTest.java less more

35	35	*/
36	36	public class LineConversionTest extends TestCase {
37	37	private IFile fFile;
38
	38
39	39	private static final String LINE_TWO= "This is the second line\n";
40	40	private static final String LINE_ONE= "This is the first line\n";
41	41	private static final String LINE_THREE= "This is the third line";

49	49	fFile.create(new ByteArrayInputStream(getFileContents().getBytes()), true, null);
50	50	super.setUp();
51	51	}
52
	52
53	53	@Override
54	54	protected void tearDown() throws Exception {
55	55	SearchPlugin.getActivePage().closeAllEditors(false);

60	60	private String getFileContents() {
61	61	return LINE_ONE+LINE_TWO+LINE_THREE;
62	62	}
63
	63
64	64	public void testConvertToCharacter() throws Exception {
65	65	SearchTestPlugin.openTextEditor(SearchPlugin.getActivePage(), fFile);
66	66	ITextFileBuffer fb= FileBuffers.getTextFileBufferManager().getTextFileBuffer(fFile.getFullPath(), LocationKind.IFILE);
67	67	IDocument doc= fb.getDocument();
68
	68
69	69	Position p1= new Position(2, 1);
70	70	Position p2= PositionTracker.convertToCharacterPosition(p1, doc);
71	71	//assertEquals(LINE_THREE, doc.get(p2.getOffset(), p2.getLength()));

86	86	assertEquals("", doc.get(p2.getOffset(), p2.getLength()));
87	87	assertEquals(p1, PositionTracker.convertToLinePosition(p2, doc));
88	88	}
89
	89
90	90	public void testBogusLines() throws Exception {
91	91	SearchTestPlugin.openTextEditor(SearchPlugin.getActivePage(), fFile);
92	92	ITextFileBuffer fb= FileBuffers.getTextFileBufferManager().getTextFileBuffer(fFile.getFullPath(), LocationKind.IFILE);

+4

-4

org.eclipse.search.tests/src/org/eclipse/search/core/tests/LongQuery.java less more

16	16	/**
17	17	*/
18	18	public class LongQuery extends NullQuery {
19
	19
20	20	private boolean fIsRunning= false;
21
	21
22	22	@Override
23	23	public boolean canRunInBackground() {
24	24	return true;
25	25	}
26
	26
27	27	@Override
28	28	public IStatus run(IProgressMonitor monitor) {
29	29	fIsRunning= true;

37	37	fIsRunning= false;
38	38	return Status.OK_STATUS;
39	39	}
40
	40
41	41	public boolean isRunning() {
42	42	return fIsRunning;
43	43	}

+1

-1

org.eclipse.search.tests/src/org/eclipse/search/core/tests/NullQuery.java less more

16	16	import org.eclipse.search.ui.ISearchResult;
17	17
18	18	public class NullQuery implements ISearchQuery {
19
	19
20	20	@Override
21	21	public IStatus run(IProgressMonitor monitor) {
22	22	return null;

+1

-1

org.eclipse.search.tests/src/org/eclipse/search/core/tests/QueryManagerTest.java less more

21	21	import org.eclipse.search2.internal.ui.InternalSearchUI;
22	22
23	23	public class QueryManagerTest {
24
	24
25	25	@Test
26	26	public void testRemoveQuery() {
27	27	ISearchQuery query= new NullQuery();

+62

-62

org.eclipse.search.tests/src/org/eclipse/search/core/tests/TestSearchResult.java less more

24	24	import org.eclipse.search.ui.text.MatchEvent;
25	25
26	26	public class TestSearchResult {
27
	27
28	28	@Test
29	29	public void testAddMatch() {
30	30	ISearchQuery query= new NullQuery();
31	31	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
32
33		String object= "object"; //$NON-NLS-1$
34
	32
	33	String object= "object"; //$NON-NLS-1$
	34
35	35	Match match1= new Match(object, 0, 0);
36	36	result.addMatch(match1);
37	37	assertEquals(result.getMatchCount(), 1);

46	46	public void testAddMatchDifferentStart() {
47	47	ISearchQuery query= new NullQuery();
48	48	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
49
50		String object= "object"; //$NON-NLS-1$
51
	49
	50	String object= "object"; //$NON-NLS-1$
	51
52	52	Match match1= new Match(object, 2, 0);
53	53	result.addMatch(match1);
54	54	assertEquals(result.getMatchCount(), 1);

66	66	public void testAddMatchDifferentStartInOrder() {
67	67	ISearchQuery query= new NullQuery();
68	68	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
69
70		String object= "object"; //$NON-NLS-1$
71
	69
	70	String object= "object"; //$NON-NLS-1$
	71
72	72	Match match1= new Match(object, 0, 0);
73	73	result.addMatch(match1);
74	74	assertEquals(result.getMatchCount(), 1);

86	86	public void testAddMatchDifferentLength() {
87	87	ISearchQuery query= new NullQuery();
88	88	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
89
90		String object= "object"; //$NON-NLS-1$
91
	89
	90	String object= "object"; //$NON-NLS-1$
	91
92	92	Match match1= new Match(object, 1, 1);
93	93	result.addMatch(match1);
94	94	assertEquals(result.getMatchCount(), 1);

98	98	assertTrue("matches[0]", matches[0] == match2);
99	99	assertTrue("matches[1]", matches[1] == match1);
100	100	}
101
	101
102	102	@Test
103	103	public void testAddMatchOrderPreserving() {
104	104	ISearchQuery query= new NullQuery();
105	105	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
106
107		String object= "object"; //$NON-NLS-1$
108
	106
	107	String object= "object"; //$NON-NLS-1$
	108
109	109	Match match1= new Match(object, 1, 0);
110	110	result.addMatch(match1);
111	111	assertEquals(result.getMatchCount(), 1);

120	120	public void testAddMatches() {
121	121	ISearchQuery query= new NullQuery();
122	122	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
123
124		String object= "object"; //$NON-NLS-1$
125
	123
	124	String object= "object"; //$NON-NLS-1$
	125
126	126	Match match1= new Match(object, 0, 0);
127	127	Match match2= new Match(object, 0, 0);
128	128	result.addMatches(new Match[] { match1, match2 });

135	135	public void testRemoveMatch() {
136	136	ISearchQuery query= new NullQuery();
137	137	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
138
139		String object= "object"; //$NON-NLS-1$
140
141		Match match1= new Match(object, 0, 0);
142		result.addMatch(match1);
143		Match match2= new Match(object, 0, 0);
144		result.addMatch(match2);
145		assertEquals(result.getMatchCount(), 2);
146
	138
	139	String object= "object"; //$NON-NLS-1$
	140
	141	Match match1= new Match(object, 0, 0);
	142	result.addMatch(match1);
	143	Match match2= new Match(object, 0, 0);
	144	result.addMatch(match2);
	145	assertEquals(result.getMatchCount(), 2);
	146
147	147	result.removeMatch(match1);
148	148	assertEquals(result.getMatchCount(), 1);
149	149	result.removeMatch(match1);
150	150	assertEquals(result.getMatchCount(), 1);
151
152		}
153
	151
	152	}
	153
154	154	@Test
155	155	public void testRemoveMatches() {
156	156	ISearchQuery query= new NullQuery();
157	157	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
158
159		String object= "object"; //$NON-NLS-1$
160
	158
	159	String object= "object"; //$NON-NLS-1$
	160
161	161	Match match1= new Match(object, 0, 0);
162	162	Match match2= new Match(object, 0, 0);
163	163	result.addMatches(new Match[] { match1, match2 });
164	164	assertEquals(result.getMatchCount(), 2);
165
	165
166	166	result.removeMatches(new Match[] { match1, match2 });
167	167	assertEquals(result.getMatchCount(), 0);
168
	168
169	169	}
170	170
171	171	@Test
172	172	public void testMatchEvent() {
173	173	final boolean [] wasAdded= { false };
174	174	final boolean [] wasRemoved= { false };
175
176		ISearchQuery query= new NullQuery();
177		AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
178
	175
	176	ISearchQuery query= new NullQuery();
	177	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
	178
179	179	result.addListener(new ISearchResultListener() {
180	180	@Override
181	181	public void searchResultChanged(SearchResultEvent e) {

189	189	}
190	190	}
191	191	});
192
193		String object= "object"; //$NON-NLS-1$
194
	192
	193	String object= "object"; //$NON-NLS-1$
	194
195	195	Match match1= new Match(object, 0, 0);
196	196	result.addMatch(match1);
197	197	assertTrue(wasAdded[0]);
198	198	wasAdded[0]= false;
199	199	result.addMatch(match1);
200	200	assertFalse(wasAdded[0]);
201
202		Match match2= new Match(object, 0, 0);
203		result.addMatch(match2);
204		assertTrue(wasAdded[0]);
205		wasAdded[0]= false;
206
	201
	202	Match match2= new Match(object, 0, 0);
	203	result.addMatch(match2);
	204	assertTrue(wasAdded[0]);
	205	wasAdded[0]= false;
	206
207	207	result.removeMatch(match2);
208	208	assertTrue(wasRemoved[0]);
209	209	wasRemoved[0]= false;
210
	210
211	211	result.removeMatch(match2);
212	212	assertFalse(wasRemoved[0]);
213	213	}
214
	214
215	215	@Test
216	216	public void testBatchedMatchEvent() {
217	217	final boolean [] wasAdded= { false };
218	218	final boolean [] wasRemoved= { false };
219
220		ISearchQuery query= new NullQuery();
221		AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
222
	219
	220	ISearchQuery query= new NullQuery();
	221	AbstractTextSearchResult result= (AbstractTextSearchResult) query.getSearchResult();
	222
223	223	result.addListener(new ISearchResultListener() {
224	224	@Override
225	225	public void searchResultChanged(SearchResultEvent e) {

233	233	}
234	234	}
235	235	});
236
237		String object= "object"; //$NON-NLS-1$
238
	236
	237	String object= "object"; //$NON-NLS-1$
	238
239	239	Match match1= new Match(object, 0, 0);
240	240	result.addMatches(new Match[] { match1 });
241	241	assertTrue(wasAdded[0]);
242	242	wasAdded[0]= false;
243	243	result.addMatches(new Match[] { match1 });
244	244	assertFalse(wasAdded[0]);
245
	245
246	246	Match match2= new Match(object, 0, 0);
247	247	result.addMatches(new Match[] { match2 });
248	248	assertTrue(wasAdded[0]);
249	249	wasAdded[0]= false;
250
	250
251	251	result.removeMatches(new Match[] { match2 });
252	252	assertTrue(wasRemoved[0]);
253	253	wasRemoved[0]= false;
254
	254
255	255	result.removeMatches(new Match[] { match2 });
256	256	assertFalse(wasRemoved[0]);
257	257	}

+33

-62

org.eclipse.search.tests/src/org/eclipse/search/tests/FileTool.java less more

31	31
32	32
33	33	public class FileTool {
34
	34
35	35	private final static int MAX_RETRY= 5;
36
	36
37	37	/**
38	38	* A buffer.
39	39	*/
40	40	private static byte[] buffer = new byte[8192];
41
	41
42	42	/**
43	43	* Unzips the given zip file to the given destination directory
44	44	* extracting only those entries the pass through the given
45	45	* filter.
46		*
	46	*
47	47	* @param zipFile the zip file to unzip
48	48	* @param dstDir the destination directory
49	49	* @throws IOException in case of problem
50	50	*/
51	51	public static void unzip(ZipFile zipFile, File dstDir) throws IOException {
52	52	Enumeration<? extends ZipEntry> entries = zipFile.entries();
53
	53
54	54	try {
55	55	while(entries.hasMoreElements()){
56	56	ZipEntry entry = entries.nextElement();

60	60	String entryName = entry.getName();
61	61	File file = new File(dstDir, changeSeparator(entryName, '/', File.separatorChar));
62	62	file.getParentFile().mkdirs();
63		InputStream src = null;
64		OutputStream dst = null;
65		try {
66		src = zipFile.getInputStream(entry);
67		dst = new FileOutputStream(file);
	63
	64	try (
	65	InputStream src = zipFile.getInputStream(entry);
	66	OutputStream dst = new FileOutputStream(file);
	67	) {
68	68	transferData(src, dst);
69		} finally {
70		if(dst != null){
71		try {
72		dst.close();
73		} catch(IOException e){
74		}
75		}
76		if(src != null){
77		try {
78		src.close();
79		} catch(IOException e){
80		}
81		}
82	69	}
83	70	}
84	71	} finally {

88	75	}
89	76	}
90	77	}
91
	78
92	79	/**
93	80	* Returns the given file path with its separator
94	81	* character changed from the given old separator to the
95	82	* given new separator.
96		*
	83	*
97	84	* @param path a file path
98	85	* @param oldSeparator a path separator character
99	86	* @param newSeparator a path separator character

104	91	public static String changeSeparator(String path, char oldSeparator, char newSeparator){
105	92	return path.replace(oldSeparator, newSeparator);
106	93	}
107
	94
108	95	/**
109	96	* Copies all bytes in the given source file to
110	97	* the given destination file.
111		*
	98	*
112	99	* @param source the given source file
113	100	* @param destination the given destination file
114	101	* @throws IOException in case of error
115	102	*/
116	103	public static void transferData(File source, File destination) throws IOException {
117	104	destination.getParentFile().mkdirs();
118		InputStream is = null;
119		OutputStream os = null;
120		try {
121		is = new FileInputStream(source);
122		os = new FileOutputStream(destination);
	105	try (
	106	InputStream is = new FileInputStream(source);
	107	OutputStream os = new FileOutputStream(destination);
	108	) {
	109
123	110	transferData(is, os);
124		} finally {
125		if(os != null){
126		try {
127		os.close();
128		} catch(IOException e){
129		}
130		}
131		if(is != null){
132		try {
133		is.close();
134		} catch(IOException e){
135		}
136		}
137		}
138		}
139
	111	}
	112	}
	113
140	114	/**
141	115	* Copies all bytes in the given source stream to
142	116	* the given destination stream. Neither streams
143	117	* are closed.
144		*
	118	*
145	119	* @param source the given source stream
146	120	* @param destination the given destination stream
147	121	* @throws IOException in case of error

158	132
159	133	/**
160	134	* Copies the given source file to the given destination file.
161		*
	135	*
162	136	* @param src the given source file
163	137	* @param dst the given destination file
164	138	* @throws IOException in case of error

166	140	public static void copy(File src, File dst) throws IOException {
167	141	if(src.isDirectory()){
168	142	String[] srcChildren = src.list();
	143	if (srcChildren == null) {
	144	throw new IOException("Content from directory '" + src.getAbsolutePath() + "' can not be listed."); //$NON-NLS-1$ //$NON-NLS-2$
	145	}
169	146	for(int i = 0; i < srcChildren.length; ++i){
170	147	File srcChild= new File(src, srcChildren[i]);
171	148	File dstChild= new File(dst, srcChildren[i]);

184	161	return null;
185	162	}
186	163	}
187
	164
188	165	public static File createTempFileInPlugin(Plugin plugin, IPath path) {
189	166	IPath stateLocation= plugin.getStateLocation();
190	167	stateLocation= stateLocation.append(path);
191	168	return stateLocation.toFile();
192	169	}
193
	170
194	171	public static StringBuffer read(String fileName) throws IOException {
195	172	return read(new FileReader(fileName));
196	173	}

214	191	}
215	192
216	193	public static void write(String fileName, StringBuffer content) throws IOException {
217		Writer writer= new FileWriter(fileName);
218		try {
	194	try (Writer writer= new FileWriter(fileName);) {
219	195	writer.write(content.toString());
220		} finally {
221		try {
222		writer.close();
223		} catch (IOException e) {
224		}
225		}
226		}
227
	196	}
	197	}
	198
228	199	public static void delete(File file) {
229	200	if (file.exists()) {
230	201	for (int i= 0; i < MAX_RETRY; i++) {

+25

-24

org.eclipse.search.tests/src/org/eclipse/search/tests/ResourceHelper.java less more

39	39	* @since 3.0
40	40	*/
41	41	public class ResourceHelper {
42
	42
43	43	private final static IProgressMonitor NULL_MONITOR= new NullProgressMonitor();
44	44	private static final int MAX_RETRY= 10;
45
	45
46	46	public static IProject createProject(String projectName) throws CoreException {
47
	47
48	48	IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
49	49	IProject project= root.getProject(projectName);
50	50	if (!project.exists())
51	51	project.create(NULL_MONITOR);
52	52	else
53	53	project.refreshLocal(IResource.DEPTH_INFINITE, null);
54
	54
55	55	if (!project.isOpen())
56	56	project.open(NULL_MONITOR);
57
	57
58	58	return project;
59	59	}
60
	60
61	61	public static void deleteProject(String projectName) throws CoreException {
62	62	IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
63	63	IProject project= root.getProject(projectName);
64	64	if (project.exists())
65	65	delete(project);
66	66	}
67
	67
68	68	public static void delete(final IResource resource) throws CoreException {
69	69	IWorkspaceRunnable runnable= new IWorkspaceRunnable() {
70	70	@Override

88	88	}
89	89	};
90	90	ResourcesPlugin.getWorkspace().run(runnable, null);
91
	91
92	92	}
93	93
94	94	/**
95	95	* Creates a folder and all parent folders if not existing. Project must exist.
96		*
	96	*
97	97	* @param folder The folder to create
98	98	* @return Returns the input folder
99	99	* @throws CoreException if creation fails

108	108	}
109	109	return folder;
110	110	}
111
	111
112	112	public static IFile createFile(IFolder folder, String name, String contents, String encoding) throws CoreException, IOException {
113	113	IFile file= folder.getFile(name);
114	114	if (contents == null)
115	115	contents= ""; //$NON-NLS-1$
116		InputStream inputStream= new ByteArrayInputStream(contents.getBytes(encoding));
117		file.create(inputStream, true, NULL_MONITOR);
118		file.setCharset(encoding, null);
119		inputStream.close();
	116	try (InputStream inputStream= new ByteArrayInputStream(contents.getBytes(encoding))) {
	117	file.create(inputStream, true, NULL_MONITOR);
	118	file.setCharset(encoding, null);
	119	}
	120
120	121	return file;
121	122	}
122
	123
123	124	public static IFile createFile(IFolder folder, String name, String contents) throws CoreException, IOException {
124	125	return createFile(folder, name, contents, "ISO-8859-1");
125	126	}
126
	127
127	128	public static IFile createLinkedFile(IContainer container, IPath linkPath, File linkedFileTarget) throws CoreException {
128	129	IFile iFile= container.getFile(linkPath);
129	130	iFile.createLink(new Path(linkedFileTarget.getAbsolutePath()), IResource.ALLOW_MISSING_LOCAL, NULL_MONITOR);
130	131	return iFile;
131	132	}
132
	133
133	134	public static IFile createLinkedFile(IContainer container, IPath linkPath, Plugin plugin, IPath linkedFileTargetPath) throws CoreException {
134	135	File file= FileTool.getFileInPlugin(plugin, linkedFileTargetPath);
135	136	IFile iFile= container.getFile(linkPath);
136	137	iFile.createLink(new Path(file.getAbsolutePath()), IResource.ALLOW_MISSING_LOCAL, NULL_MONITOR);
137	138	return iFile;
138	139	}
139
	140
140	141	public static IFolder createLinkedFolder(IContainer container, IPath linkPath, File linkedFolderTarget) throws CoreException {
141	142	IFolder folder= container.getFolder(linkPath);
142	143	folder.createLink(new Path(linkedFolderTarget.getAbsolutePath()), IResource.ALLOW_MISSING_LOCAL, NULL_MONITOR);
143	144	return folder;
144	145	}
145
	146
146	147	public static IFolder createLinkedFolder(IContainer container, IPath linkPath, Plugin plugin, IPath linkedFolderTargetPath) throws CoreException {
147	148	File file= FileTool.getFileInPlugin(plugin, linkedFolderTargetPath);
148	149	IFolder iFolder= container.getFolder(linkPath);
149	150	iFolder.createLink(new Path(file.getAbsolutePath()), IResource.ALLOW_MISSING_LOCAL, NULL_MONITOR);
150	151	return iFolder;
151	152	}
152
	153
153	154	public static IProject createLinkedProject(String projectName, Plugin plugin, IPath linkPath) throws CoreException {
154	155	IWorkspace workspace= ResourcesPlugin.getWorkspace();
155	156	IProject project= workspace.getRoot().getProject(projectName);
156
	157
157	158	IProjectDescription desc= workspace.newProjectDescription(projectName);
158	159	File file= FileTool.getFileInPlugin(plugin, linkPath);
159	160	IPath projectLocation= new Path(file.getAbsolutePath());
160	161	if (Platform.getLocation().equals(projectLocation))
161	162	projectLocation= null;
162	163	desc.setLocation(projectLocation);
163
	164
164	165	project.create(desc, NULL_MONITOR);
165	166	if (!project.isOpen())
166	167	project.open(NULL_MONITOR);
167
	168
168	169	return project;
169	170	}
170
	171
171	172	public static IProject createJUnitSourceProject(String projectName) throws CoreException, ZipException, IOException {
172	173	IProject project= ResourceHelper.createProject(projectName);
173	174	ZipFile zip= new ZipFile(FileTool.getFileInPlugin(SearchTestPlugin.getDefault(), new Path("testresources/junit37-noUI-src.zip"))); //$NON-NLS-1$

+2

-2

org.eclipse.search.tests/src/org/eclipse/search/tests/SearchTestPlugin.java less more

34	34	public class SearchTestPlugin extends AbstractUIPlugin {
35	35	//The shared instance.
36	36	private static SearchTestPlugin fgPlugin;
37
	37
38	38	public SearchTestPlugin() {
39	39	fgPlugin = this;
40	40	}

42	42	public static SearchTestPlugin getDefault() {
43	43	return fgPlugin;
44	44	}
45
	45
46	46	public SearchView getSearchView() {
47	47	return (SearchView) NewSearchUI.activateSearchResultView();
48	48	}

+13

-13

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/AnnotationManagerTest.java less more

64	64	fQuery1= new FileSearchQuery("Test", false, true, scope); //$NON-NLS-1$//$NON-NLS-2$
65	65	fQuery2= new FileSearchQuery("Test", false, true, scope); //$NON-NLS-1$//$NON-NLS-2$
66	66	}
67
	67
68	68	@After
69	69	public void tearDown() {
70	70	InternalSearchUI.getInstance().removeAllQueries();
71	71	fQuery1= null;
72	72	fQuery2= null;
73
	73
74	74	EditorAnnotationManager.debugSetHighlighterType(EditorAnnotationManager.HIGHLLIGHTER_ANY);
75	75
76	76	}

93	93	positions.add(annotationModel.getPosition(annotation));
94	94	}
95	95	}
96
	96
97	97	Match[] matches= result.getMatches(file);
98	98	for (int j= 0; j < matches.length; j++) {
99	99	Position position= new Position(matches[j].getOffset(), matches[j].getLength());
100	100	assertTrue("position not found at: "+j, positions.remove(position)); //$NON-NLS-1$
101	101	}
102	102	assertEquals(0, positions.size());
103
104		}
105		} finally {
106		SearchPlugin.getActivePage().closeAllEditors(false);
107		}
108		}
109
	103
	104	}
	105	} finally {
	106	SearchPlugin.getActivePage().closeAllEditors(false);
	107	}
	108	}
	109
110	110	@Test
111	111	public void testBogusAnnotation() throws Exception {
112	112	NewSearchUI.runQueryInForeground(null, fQuery1);

115	115	SearchTestPlugin.openTextEditor(SearchTestPlugin.getDefault().getWorkbench().getWorkbenchWindows()[0].getPages()[0], file);
116	116	result.addMatch(new FileMatch(file));
117	117	}
118
	118
119	119	@Test
120	120	public void testRemoveQuery() throws Exception {
121	121	NewSearchUI.runQueryInForeground(null, fQuery1);
122	122	AbstractTextSearchResult result= (AbstractTextSearchResult) fQuery1.getSearchResult();
123	123	Object[] files= result.getElements();
124	124	InternalSearchUI.getInstance().removeQuery(fQuery1);
125
	125
126	126	try {
127	127	for (int i= 0; i < files.length; i++) {
128	128	IFile file= (IFile)files[i];

169	169	SearchPlugin.getActivePage().closeAllEditors(false);
170	170	}
171	171	}
172
	172
173	173	@Test
174	174	public void testSwitchQuery() throws Exception {
175	175	NewSearchUI.runQueryInForeground(null, fQuery1);

+20

-20

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/FileCharSequenceTests.java less more

30	30	public class FileCharSequenceTests {
31	31
32	32	private final String TEST_CONTENT= "ABCDEFGHIJKLMNOPQRSTUVWXYZÜöäüèéùabcdefghijklmnopqrstuvwxyz1234567890@\'\"\n$¢"; //€
33
	33
34	34	private IProject fProject;
35
	35
36	36	@Before
37	37	public void setUp() throws Exception {
38	38	fProject= ResourceHelper.createProject("my-project"); //$NON-NLS-1$
39	39	}
40
	40
41	41	@After
42	42	public void tearDown() throws Exception {
43	43	ResourceHelper.deleteProject("my-project"); //$NON-NLS-1$
44	44	}
45
	45
46	46	@Test
47	47	public void testFileCharSequence() throws Exception {
48		StringBuffer buf= new StringBuffer();
	48	StringBuilder buf= new StringBuilder();
49	49	for (int i= 0; i < 500; i++) {
50	50	buf.append(TEST_CONTENT);
51	51	}

55	55
56	56	@Test
57	57	public void testFileCharSequence2() throws Exception {
58		StringBuffer buf= new StringBuffer();
	58	StringBuilder buf= new StringBuilder();
59	59	for (int i= 0; i < 2000; i++) {
60	60	buf.append(TEST_CONTENT);
61	61	}

65	65
66	66	@Test
67	67	public void testFileCharSequence3() throws Exception {
68		StringBuffer buf= new StringBuffer();
	68	StringBuilder buf= new StringBuilder();
69	69	for (int i= 0; i < FileCharSequenceProvider.BUFFER_SIZE * 2; i++) {
70	70	buf.append(TEST_CONTENT);
71	71	}

76	76	private void testForEncoding(CharSequence buf, String encoding) throws CoreException, IOException {
77	77	IFolder folder= ResourceHelper.createFolder(fProject.getFolder("folder1"));
78	78	IFile file1= ResourceHelper.createFile(folder, "file1", buf.toString(), encoding);
79
	79
80	80	FileCharSequenceProvider provider= new FileCharSequenceProvider();
81	81	CharSequence cs= null;
82	82	try {
83	83	cs= provider.newCharSequence(file1);
84
	84
85	85	assertEquals(encoding, cs, buf);
86
	86
87	87	assertSubSequence(encoding, cs, buf, 0, buf.length() / 6);
88	88	assertSubSequence(encoding, cs, buf, buf.length() / 6, FileCharSequenceProvider.BUFFER_SIZE);
89
	89
90	90	int pos= 8 * buf.length() / 9;
91	91	assertSubSequence(encoding, cs, buf, pos, buf.length() - pos);
92
	92
93	93	CharSequence seq1a= cs.subSequence(100, 100 + FileCharSequenceProvider.BUFFER_SIZE);
94	94	CharSequence seq1e= buf.subSequence(100, 100 + FileCharSequenceProvider.BUFFER_SIZE);
95	95	assertSubSequence(encoding, seq1a, seq1e, 500, 500);
96
	96
97	97	assertSubSequence(encoding, seq1a, seq1e, FileCharSequenceProvider.BUFFER_SIZE, 0);
98
	98
99	99	} finally {
100	100	if (cs != null) {
101	101	provider.releaseCharSequence(cs);

103	103	file1.delete(true, null);
104	104	}
105	105	}
106
	106
107	107	private void assertSubSequence(String message, CharSequence actual, CharSequence expected, int start, int length) {
108	108	CharSequence actualSub= actual.subSequence(start, start + length);
109	109	CharSequence expectedSub= expected.subSequence(start, start + length);
110	110	assertEquals(message + " - subsequence(" + start + ", " + length + ")", actualSub, expectedSub);
111	111	}
112
	112
113	113	private void assertEquals(String desc, CharSequence actual, CharSequence expected) {
114	114	for (int i= 0; i < expected.length(); i++) {
115	115	Assert.assertEquals(desc + " - forward " + i, expected.charAt(i), actual.charAt(i));

124	124	for (int i= 0; i < expected.length(); i+= FileCharSequenceProvider.BUFFER_SIZE) {
125	125	Assert.assertEquals(desc + " - forward - buffersize" + i, expected.charAt(i), actual.charAt(i));
126	126	}
127
	127
128	128	assertOutOfBound(desc + "access at length", actual, expected.length());
129	129	assertOutOfBound(desc + "access at -1", actual, -1);
130	130
131	131	Assert.assertEquals(desc + " - length", actual.toString(), expected.toString());
132	132	}
133
134
	133
	134
135	135	private void assertOutOfBound(String message, CharSequence cs, int i) {
136	136	try {
137	137	cs.charAt(i);

142	142	}
143	143
144	144
145
	145
146	146	}

+107

-52

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/FileSearchTests.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2016 IBM Corporation and others.
	1	* Copyright (c) 2000, 2017 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

8	8	* IBM Corporation - initial API and implementation
9	9	* Christian Walther (Indel AG) - Bug 399094, 402009: Add whole word option to file search
10	10	* Terry Parker <tparker@google.com> (Google Inc.) - Bug 441016 - Speed up text search by parallelizing it using JobGroups
	11	* Florian Ingerl <imelflorianingerl@gmail.com> - Bug 109481 - [find/replace] replace doesn't work when using a regex with a lookahead or boundary matchers
11	12	*******************************************************************************/
12	13	package org.eclipse.search.tests.filesearch;
13	14
14	15	import static org.junit.Assert.assertEquals;
15	16
	17	import java.io.IOException;
16	18	import java.util.ArrayList;
17	19	import java.util.List;
	20	import java.util.Scanner;
18	21	import java.util.regex.Pattern;
19	22
20	23	import org.junit.After;

23	26	import org.junit.Test;
24	27
25	28	import org.eclipse.core.runtime.CoreException;
	29	import org.eclipse.core.runtime.NullProgressMonitor;
	30	import org.eclipse.core.runtime.OperationCanceledException;
26	31
27	32	import org.eclipse.core.resources.IFile;
28	33	import org.eclipse.core.resources.IFolder;

37	42	import org.eclipse.search.core.text.TextSearchScope;
38	43	import org.eclipse.search.internal.core.text.PatternConstructor;
39	44	import org.eclipse.search.internal.ui.SearchPlugin;
	45	import org.eclipse.search.internal.ui.text.FileSearchQuery;
	46	import org.eclipse.search.internal.ui.text.FileSearchResult;
	47	import org.eclipse.search.internal.ui.text.ReplaceRefactoring;
40	48	import org.eclipse.search.tests.ResourceHelper;
41	49	import org.eclipse.search.tests.SearchTestPlugin;
42	50	import org.eclipse.search.ui.text.FileTextSearchScope;
43	51
	52	import org.eclipse.ltk.core.refactoring.Change;
	53
44	54	public class FileSearchTests {
45
	55
46	56	private static class TestResult {
47	57	public IResource resource;
48	58	public int offset;

113	123	public static JUnitSourceSetup fgJUnitSource= new JUnitSourceSetup();
114	124
115	125	private IProject fProject;
116
	126
117	127	@Before
118	128	public void setUp() throws Exception{
119	129	fProject= ResourceHelper.createProject("my-project"); //$NON-NLS-1$
120	130	}
121
	131
122	132	@After
123	133	public void tearDown() throws Exception {
124	134	ResourceHelper.deleteProject("my-project"); //$NON-NLS-1$

128	138	public void testSimpleFilesSerial() throws Exception {
129	139	testSimpleFiles(new SerialTestResultCollector());
130	140	}
131
	141
132	142	@Test
133	143	public void testSimpleFilesParallel() throws Exception {
134	144	testSimpleFiles(new ParallelTestResultCollector());
135	145	}
136	146
137	147	private void testSimpleFiles(TestResultCollector collector) throws Exception {
138		StringBuffer buf= new StringBuffer();
	148	StringBuilder buf= new StringBuilder();
139	149	buf.append("File1\n");
140	150	buf.append("hello\n");
141	151	buf.append("more hello\n");

155	165	assertMatches(results, 2, file1, buf.toString(), "hello");
156	166	assertMatches(results, 2, file2, buf.toString(), "hello");
157	167	}
158
	168
159	169	@Test
160	170	public void testWildCards1Serial() throws Exception {
161	171	testWildCards1(new SerialTestResultCollector());
162	172	}
163
	173
164	174	@Test
165	175	public void testWildCards1Parallel() throws Exception {
166	176	testWildCards1(new ParallelTestResultCollector());
167	177	}
168	178
169	179	private void testWildCards1(TestResultCollector collector) throws Exception {
170		StringBuffer buf= new StringBuffer();
	180	StringBuilder buf= new StringBuilder();
171	181	buf.append("File1\n");
172	182	buf.append("no more\n");
173	183	buf.append("mornings\n");

178	188	ResourceHelper.createFile(folder, "file2", buf.toString());
179	189
180	190	Pattern searchPattern= PatternConstructor.createPattern("mor*", false, false);
181
	191
182	192	FileTextSearchScope scope= FileTextSearchScope.newSearchScope(new IResource[] {fProject}, (String[]) null, false);
183	193	TextSearchEngine.create().search(scope, collector, searchPattern, null);
184
	194
185	195	TestResult[] results= collector.getResults();
186	196	assertEquals("Number of total results", 6, results.length);
187	197	}
188
	198
189	199	@Test
190	200	public void testWildCards2Serial() throws Exception {
191	201	testWildCards2(new SerialTestResultCollector());
192	202	}
193
	203
194	204	@Test
195	205	public void testWildCards2Parallel() throws Exception {
196	206	testWildCards2(new ParallelTestResultCollector());
197	207	}
198	208
199	209	private void testWildCards2(TestResultCollector collector) throws Exception {
200		StringBuffer buf= new StringBuffer();
	210	StringBuilder buf= new StringBuilder();
201	211	buf.append("File1\n");
202	212	buf.append("no more\n");
203	213	buf.append("mornings\n");

208	218	ResourceHelper.createFile(folder, "file2", buf.toString());
209	219
210	220	Pattern searchPattern= PatternConstructor.createPattern("mo?e", false, false);
211
	221
212	222	FileTextSearchScope scope= FileTextSearchScope.newSearchScope(new IResource[] {fProject}, (String[]) null, false);
213	223	TextSearchEngine.create().search(scope, collector, searchPattern, null);
214
	224
215	225	TestResult[] results= collector.getResults();
216	226	assertEquals("Number of total results", 4, results.length);
217	227	}
218
	228
219	229	@Test
220	230	public void testWildCards3Serial() throws Exception {
221	231	testWildCards3(new SerialTestResultCollector());
222	232	}
223
	233
224	234	@Test
225	235	public void testWildCards3Parallel() throws Exception {
226	236	testWildCards3(new ParallelTestResultCollector());
227	237	}
228	238
229	239	private void testWildCards3(TestResultCollector collector) throws Exception {
230
	240
231	241	IProject project= fgJUnitSource.getStandardProject();
232	242	IFile openFile1= (IFile) project.findMember("junit/framework/TestCase.java");
233	243	IFile openFile2= (IFile) project.findMember("junit/extensions/ExceptionTestCase.java");
234	244	IFile openFile3= (IFile) project.findMember("junit/framework/Assert.java");
235	245	IFile openFile4= (IFile) project.findMember("junit/samples/money/MoneyTest.java");
236
	246
237	247	IWorkbenchPage activePage= SearchPlugin.getActivePage();
238	248	try {
239	249	SearchTestPlugin.openTextEditor(activePage, openFile1);
240	250	SearchTestPlugin.openTextEditor(activePage, openFile2);
241	251	SearchTestPlugin.openTextEditor(activePage, openFile3);
242	252	SearchTestPlugin.openTextEditor(activePage, openFile4);
243
	253
244	254	long start= System.currentTimeMillis();
245	255
246	256	Pattern searchPattern= PatternConstructor.createPattern("\\w*\$\$", false, true);

259	269	}
260	270
261	271	}
262
	272
263	273	@Test
264	274	public void testWholeWordSerial() throws Exception {
265	275	testWholeWord(new SerialTestResultCollector());
266	276	}
267
	277
268	278	@Test
269	279	public void testWholeWordParallel() throws Exception {
270	280	testWholeWord(new ParallelTestResultCollector());
271	281	}
272	282
273	283	private void testWholeWord(TestResultCollector collector) throws Exception {
274		StringBuffer buf= new StringBuffer();
	284	StringBuilder buf= new StringBuilder();
275	285	// nothing after
276	286	buf.append("hell\n"); // nothing before
277	287	buf.append("hill\n"); // nothing before

315	325	assertEquals("Number of partial-word results", 22, collector.getNumberOfResults());
316	326	}
317	327	}
318
	328
319	329	@Test
320	330	public void testFileOpenInEditorSerial() throws Exception {
321	331	testFileOpenInEditor(new SerialTestResultCollector());
322	332	}
323
	333
324	334	@Test
325	335	public void testFileOpenInEditorParallel() throws Exception {
326	336	testFileOpenInEditor(new ParallelTestResultCollector());
327	337	}
328	338
329	339	private void testFileOpenInEditor(TestResultCollector collector) throws Exception {
330		StringBuffer buf= new StringBuffer();
	340	StringBuilder buf= new StringBuilder();
331	341	buf.append("File1\n");
332	342	buf.append("hello\n");
333	343	buf.append("more hello\n");

338	348
339	349	try {
340	350	SearchTestPlugin.openTextEditor(SearchPlugin.getActivePage(), file2);
341
	351
342	352	Pattern searchPattern= PatternConstructor.createPattern("hello", false, true);
343	353
344	354	FileTextSearchScope scope= FileTextSearchScope.newSearchScope(new IResource[] {fProject}, (String[]) null, false);

353	363	SearchPlugin.getActivePage().closeAllEditors(false);
354	364	}
355	365	}
356
	366
357	367	@Test
358	368	public void testDerivedFilesSerial() throws Exception {
359	369	testDerivedFiles(new SerialTestResultCollector());
360	370	}
361
	371
362	372	@Test
363	373	public void testDerivedFilesParallel() throws Exception {
364	374	testDerivedFiles(new ParallelTestResultCollector());
365	375	}
366	376
367	377	private void testDerivedFiles(TestResultCollector collector) throws Exception {
368		StringBuffer buf= new StringBuffer();
	378	StringBuilder buf= new StringBuilder();
369	379	buf.append("hello\n");
370	380	IFolder folder1= ResourceHelper.createFolder(fProject.getFolder("folder1"));
371	381	ResourceHelper.createFile(folder1, "file1", buf.toString());
372	382	IFile file2= ResourceHelper.createFile(folder1, "file2", buf.toString());
373	383	file2.setDerived(true, null);
374
	384
375	385	IFolder folder2= ResourceHelper.createFolder(folder1.getFolder("folder2"));
376	386	folder2.setDerived(true, null);
377	387	ResourceHelper.createFile(folder2, "file3", buf.toString());
378	388
379	389	IFolder folder3= ResourceHelper.createFolder(folder2.getFolder("folder3"));
380	390	ResourceHelper.createFile(folder3, "file4", buf.toString());
381
	391
382	392	IFolder folder4= ResourceHelper.createFolder(folder1.getFolder("folder4"));
383	393	ResourceHelper.createFile(folder4, "file5", buf.toString());
384
	394
385	395	/**
386	396	* folder1
387	397	* file1

393	403	* folder4
394	404	* file5
395	405	*/
396
397
	406
	407
398	408	Pattern searchPattern= PatternConstructor.createPattern("hello", false, true);
399	409	Pattern fileNamePattern= PatternConstructor.createPattern("*", false, false);
400	410	TextSearchEngine engine= TextSearchEngine.create();

441	451	assertEquals(0, collector.getNumberOfResults());
442	452	}
443	453	}
444
	454
445	455	@Test
446	456	public void testFileNamePatternsSerial() throws Exception {
447	457	testFileNamePatterns(new SerialTestResultCollector());
448	458	}
449
	459
450	460	@Test
451	461	public void testFileNamePatternsParallel() throws Exception {
452	462	testFileNamePatterns(new ParallelTestResultCollector());

462	472
463	473	Pattern searchPattern= PatternConstructor.createPattern("Test", false, false);
464	474	String[] fileNamePatterns= { "*" };
465
	475
466	476	TestResult[] results= performSearch(collector, fileNamePatterns, searchPattern);
467	477	assertEquals("Number of total results", 4, results.length);
468
	478
469	479	fileNamePatterns= new String[] { "*.x" };
470	480	results= performSearch(collector, fileNamePatterns, searchPattern);
471	481	assertEquals("Number of total results", 2, results.length);
472
	482
473	483	fileNamePatterns= new String[] { ".x", ".y*" };
474	484	results= performSearch(collector, fileNamePatterns, searchPattern);
475	485	assertEquals("Number of total results", 3, results.length);
476
	486
477	487	fileNamePatterns= new String[] { "!*.x" };
478	488	results= performSearch(collector, fileNamePatterns, searchPattern);
479	489	assertEquals("Number of total results", 2, results.length);
480
	490
481	491	fileNamePatterns= new String[] { "!.x", "!.y" };
482	492	results= performSearch(collector, fileNamePatterns, searchPattern);
483	493	assertEquals("Number of total results", 1, results.length);
484
	494
485	495	fileNamePatterns= new String[] { "", "!.y" };
486	496	results= performSearch(collector, fileNamePatterns, searchPattern);
487	497	assertEquals("Number of total results", 3, results.length);
488
	498
489	499	fileNamePatterns= new String[] { "", "!.*" };
490	500	results= performSearch(collector, fileNamePatterns, searchPattern);
491	501	assertEquals("Number of total results", 0, results.length);
492
	502
493	503	fileNamePatterns= new String[] { ".x", ".y", "!.y" };
494	504	results= performSearch(collector, fileNamePatterns, searchPattern);
495	505	assertEquals("Number of total results", 2, results.length);
496
	506
497	507	fileNamePatterns= new String[] { "file", "!.x", "!.y" };
498	508	results= performSearch(collector, fileNamePatterns, searchPattern);
499	509	assertEquals("Number of total results", 1, results.length);
500	510	}
501
	511
502	512	private TestResult[] performSearch(TestResultCollector collector, String[] fileNamePatterns, Pattern searchPattern) {
503	513	collector.reset();
504	514	FileTextSearchScope scope= FileTextSearchScope.newSearchScope(new IResource[] {fProject}, fileNamePatterns, false);
505	515	TextSearchEngine.create().search(scope, collector, searchPattern, null);
506
	516
507	517	return collector.getResults();
508	518
509	519	}
510
	520
511	521
512	522
513	523	private void assertMatches(TestResult[] results, int expectedCount, IFile file, String fileContent, String string) {

521	531	}
522	532	assertEquals("Number of results in file", expectedCount, k);
523	533	}
524
525
	534
	535	@Test
	536	public void testReplaceWithLookarounds() throws CoreException, IOException {
	537	IFolder folder= ResourceHelper.createFolder(fProject.getFolder("folder1"));
	538	IFile file1= ResourceHelper.createFile(folder, "file1.txt", "1<2<3<4");
	539	IFile file2= ResourceHelper.createFile(folder, "file2.txt", "4<5<6<7");
	540
	541	FileSearchResult searchResult= performSearch(new String[] { "*.txt" }, "(?<=(\\d)\\<)\\d(?=\\<(\\d))");
	542	performReplace(searchResult, "$0=($1+$2)/2");
	543
	544	assertFileContent(file1, "1<2=(1+3)/2<3=(2+4)/2<4");
	545	assertFileContent(file2, "4<5=(4+6)/2<6=(5+7)/2<7");
	546	}
	547
	548	@Test
	549	public void testReplaceRetainCase() throws CoreException, IOException {
	550	IFolder folder= ResourceHelper.createFolder(fProject.getFolder("folder1"));
	551	IFile file1= ResourceHelper.createFile(folder, "file1.txt", "FOO");
	552
	553	FileSearchResult searchResult= performSearch(new String[] { "*.txt" }, "FOO");
	554	performReplace(searchResult, "xyz\\Cbar\\Cfar");
	555
	556	assertFileContent(file1, "xyzBARFAR");
	557	}
	558
	559	private FileSearchResult performSearch(String[] fileNamePatterns, String pattern) {
	560	FileTextSearchScope scope= FileTextSearchScope.newSearchScope(new IResource[] { fProject }, fileNamePatterns, false);
	561	FileSearchQuery query= new FileSearchQuery(pattern, true, true, scope);
	562	query.run(null);
	563	return (FileSearchResult) query.getSearchResult();
	564	}
	565
	566	private void performReplace(FileSearchResult searchResult, String replacementText) throws OperationCanceledException, CoreException {
	567	ReplaceRefactoring refactoring= new ReplaceRefactoring(searchResult, null);
	568	refactoring.setReplaceString(replacementText);
	569	refactoring.checkInitialConditions(null);
	570	refactoring.checkFinalConditions(null);
	571	Change change= refactoring.createChange(null);
	572	change.perform(new NullProgressMonitor());
	573	}
	574
	575	private void assertFileContent(IFile file, String expected) throws CoreException {
	576	try (Scanner scanner= new Scanner(file.getContents())) {
	577	scanner.useDelimiter("\\A");
	578	assertEquals(expected, scanner.next());
	579	}
	580	}
526	581	}

+6

-6

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/JUnitSourceSetup.java less more

19	19	import org.eclipse.search.tests.ResourceHelper;
20	20
21	21	public class JUnitSourceSetup extends ExternalResource {
22
	22
23	23	public static final String STANDARD_PROJECT_NAME= "JUnitSource";
24
	24
25	25	private IProject fProject= null;
26	26	private final String fProjectName;
27
	27
28	28	public IProject getStandardProject() {
29	29	return ResourcesPlugin.getWorkspace().getRoot().getProject(STANDARD_PROJECT_NAME);
30	30	}

32	32	public JUnitSourceSetup() {
33	33	this(STANDARD_PROJECT_NAME);
34	34	}
35
	35
36	36	public JUnitSourceSetup(String projectName) {
37	37	fProjectName= projectName;
38	38	}
39
	39
40	40	@Override
41	41	public void before() throws Exception {
42	42	IProject project= ResourcesPlugin.getWorkspace().getRoot().getProject(fProjectName);

44	44	fProject= ResourceHelper.createJUnitSourceProject(fProjectName);
45	45	}
46	46	}
47
	47
48	48	@Override
49	49	public void after() /throws Exception (but JUnit4 API is stupid...)/ {
50	50	if (fProject != null) { // delete only by the setup who created the project

+6

-6

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/LineAnnotationManagerTest.java less more

56	56	@Before
57	57	public void setUp() throws Exception {
58	58	EditorAnnotationManager.debugSetHighlighterType(EditorAnnotationManager.HIGHLIGHTER_ANNOTATION);
59
	59
60	60	String[] fileNamePatterns= { "*.java" };
61	61	FileTextSearchScope scope= FileTextSearchScope.newWorkspaceScope(fileNamePatterns, false);
62
	62
63	63	fLineQuery= new LineBasedFileSearch(scope, false, true, "Test");
64	64	}
65
	65
66	66	@After
67	67	public void tearDown() throws Exception {
68	68	InternalSearchUI.getInstance().removeAllQueries();
69	69	fLineQuery= null;
70
	70
71	71	EditorAnnotationManager.debugSetHighlighterType(EditorAnnotationManager.HIGHLLIGHTER_ANY);
72	72	}
73
74		@Test
	73
	74	@Test
75	75	public void testLineBasedQuery() throws Exception {
76	76	NewSearchUI.runQueryInForeground(null, fLineQuery);
77	77	AbstractTextSearchResult result= (AbstractTextSearchResult) fLineQuery.getSearchResult();

+12

-12

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/LineBasedFileSearch.java less more

38	38	/**
39	39	*/
40	40	public class LineBasedFileSearch extends FileSearchQuery {
41
42
	41
	42
43	43	private static class LineBasedTextSearchResultCollector extends TextSearchRequestor {
44
	44
45	45	private final AbstractTextSearchResult fResult;
46	46	private IFile fLastFile;
47		private IDocument fLastDocument;
	47	private IDocument fLastDocument;
48	48	private Object fLock= new Object();
49	49
50	50	private LineBasedTextSearchResultCollector(AbstractTextSearchResult result) {

86	86	FileBuffers.getTextFileBufferManager().disconnect(fLastFile.getFullPath(), LocationKind.IFILE, null);
87	87	}
88	88	fLastFile= file;
89
	89
90	90	FileBuffers.getTextFileBufferManager().connect(file.getFullPath(), LocationKind.IFILE, null);
91	91	fLastDocument= FileBuffers.getTextFileBufferManager().getTextFileBuffer(file.getFullPath(), LocationKind.IFILE).getDocument();
92	92	return fLastDocument;
93	93	}
94
	94
95	95	@Override
96	96	public void endReporting() {
97	97	if (fLastFile != null) {

102	102	}
103	103	}
104	104	}
105
	105
106	106	private final FileTextSearchScope fScope;
107
108
	107
	108
109	109	public LineBasedFileSearch(FileTextSearchScope scope, boolean isRegEx, boolean isCaseSensitive, String searchString) {
110	110	super(searchString, isRegEx, isCaseSensitive, scope);
111	111	fScope= scope;

116	116	public IStatus run(IProgressMonitor monitor) {
117	117	AbstractTextSearchResult textResult= (AbstractTextSearchResult) getSearchResult();
118	118	textResult.removeAll();
119
	119
120	120	LineBasedTextSearchResultCollector collector= new LineBasedTextSearchResultCollector(textResult);
121
	121
122	122	Pattern searchPattern= getSearchPattern();
123	123	return TextSearchEngine.create().search(fScope, collector, searchPattern, monitor);
124	124	}
125
	125
126	126
127	127	}

+6

-6

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/PositionTrackerTest.java less more

49	49	public void setUp() throws Exception {
50	50	String[] fileNamePatterns= { "*.java" };
51	51	FileTextSearchScope scope= FileTextSearchScope.newWorkspaceScope(fileNamePatterns, false);
52
	52
53	53	fQuery1= new FileSearchQuery("Test", false, true, scope);
54	54	}
55
56
	55
	56
57	57	@Test
58	58	public void testInsertAt0() throws Exception {
59	59	NewSearchUI.runQueryInForeground(null, fQuery1);

67	67	SearchPlugin.getActivePage().closeAllEditors(false);
68	68	}
69	69	}
70
	70
71	71	@Test
72	72	public void testInsertInsideMatch() throws Exception {
73	73	NewSearchUI.runQueryInForeground(null, fQuery1);

100	100	Position currentPosition= InternalSearchUI.getInstance().getPositionTracker().getCurrentPosition(matches[i]);
101	101	assertNotNull(currentPosition);
102	102	String text= doc.get(currentPosition.offset, currentPosition.length);
103		StringBuffer buf= new StringBuffer();
	103	StringBuilder buf= new StringBuilder();
104	104	buf.append(text.charAt(0));
105	105	buf.append(text.substring(5));
106	106	assertEquals(buf.toString(), ((FileSearchQuery) result.getQuery()).getSearchString());

132	132	SearchPlugin.getActivePage().closeAllEditors(false);
133	133	}
134	134	}
135
	135
136	136	}

+7

-7

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/ResultUpdaterTest.java less more

29	29
30	30	public class ResultUpdaterTest {
31	31	private FileSearchQuery fQuery1;
32
	32
33	33	private IProject fProject;
34
	34
35	35	private static final String PROJECT_TO_MODIFY= "ModifiableProject";
36	36
37	37	@Before
38	38	public void setUp() throws Exception {
39	39	// create a own project to make modifications
40	40	fProject= ResourceHelper.createJUnitSourceProject(PROJECT_TO_MODIFY);
41
	41
42	42	String[] fileNamePatterns= { "*.java" };
43	43	FileTextSearchScope scope= FileTextSearchScope.newSearchScope(new IResource[] { fProject }, fileNamePatterns, false);
44
	44
45	45	fQuery1= new FileSearchQuery("Test", false, true, scope);
46	46	}
47
	47
48	48	@After
49	49	public void tearDown() throws Exception {
50	50	ResourceHelper.deleteProject(PROJECT_TO_MODIFY);
51	51	}
52
	52
53	53	@Test
54	54	public void testRemoveFile() throws Exception {
55	55	NewSearchUI.runQueryInForeground(null, fQuery1);

61	61	assertEquals(totalCount-fileCount, result.getMatchCount());
62	62	assertEquals(0, result.getMatchCount(elements[0]));
63	63	}
64
	64
65	65	@Test
66	66	public void testRemoveProject() throws Exception {
67	67	NewSearchUI.runQueryInForeground(null, fQuery1);

+11

-11

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/SearchResultPageTest.java less more

51	51	SearchTestPlugin.ensureWelcomePageClosed();
52	52	String[] fileNamePatterns= { "*.java" };
53	53	FileTextSearchScope scope= FileTextSearchScope.newWorkspaceScope(fileNamePatterns, false);
54
	54
55	55	fQuery1= new FileSearchQuery("Test", false, true, scope);
56	56	}
57	57

66	66	page.setLayout(AbstractTextSearchViewPage.FLAG_LAYOUT_FLAT);
67	67	checkViewerDisplay(page);
68	68	}
69
	69
70	70	private void checkViewerDisplay(FileSearchPage page) {
71	71	StructuredViewer viewer= page.getViewer();
72	72	AbstractTextSearchResult result= (AbstractTextSearchResult) fQuery1.getSearchResult();

80	80	}
81	81	}
82	82
83
	83
84	84	@Test
85	85	@Ignore // checkElementDisplay(..) misses cases where one line contains multiple matches
86	86	public void testRemoveTreeMatches() throws Exception {

112	112	Display.getDefault().readAndDispatch();
113	113	}
114	114	}
115
	115
116	116	private void consumeEvents() {
117	117	while (Display.getDefault().readAndDispatch()) {
118	118	}

127	127	if (itemCount > 1)
128	128	assertTrue(item.getText().indexOf(String.valueOf(itemCount)) >= 0);
129	129	}
130
	130
131	131	@Test
132	132	public void testTableNavigation() {
133	133	NewSearchUI.runQueryInForeground(null, fQuery1);

135	135	FileSearchPage page= (FileSearchPage) view.getActivePage();
136	136	page.setLayout(AbstractTextSearchViewPage.FLAG_LAYOUT_FLAT);
137	137	Table table= ((TableViewer) page.getViewer()).getTable();
138
	138
139	139	consumeEvents();
140
	140
141	141	// select the first element.
142	142	table.setSelection(0);
143	143	table.showSelection();
144
	144
145	145	consumeEvents();
146	146	// back from first match, goto last
147	147	page.gotoPreviousMatch();
148
	148
149	149	consumeEvents();
150
	150
151	151	assertEquals(1, table.getSelectionCount());
152	152	assertEquals(table.getItemCount()-1, table.getSelectionIndex());
153	153
154	154	// and forward again, to the first match.
155	155	page.gotoNextMatch();
156
	156
157	157	consumeEvents();
158	158	assertEquals(1, table.getSelectionCount());
159	159	assertEquals(0, table.getSelectionIndex());

+7

-7

org.eclipse.search.tests/src/org/eclipse/search/tests/filesearch/SortingTest.java less more

35	35	public void setUp() throws Exception {
36	36	String[] fileNamePatterns= { "*.java" };
37	37	FileTextSearchScope scope= FileTextSearchScope.newWorkspaceScope(fileNamePatterns, false);
38
	38
39	39	fQuery1= new FileSearchQuery("Test", false, true, scope);
40	40	}
41
	41
42	42	@Test
43	43	public void testSorted() throws Exception {
44	44	NewSearchUI.activateSearchResultView();

46	46	AbstractTextSearchResult result= (AbstractTextSearchResult) fQuery1.getSearchResult();
47	47	int originalMatchCount= result.getMatchCount();
48	48	List<Match> allMatches= new ArrayList<>(originalMatchCount);
49
	49
50	50	// first, collect all matches
51	51	Object[] elements= result.getElements();
52	52	for (int i= 0; i < elements.length; i++) {

58	58	// now remove them and readd them in reverse order
59	59	result.removeAll();
60	60	assertTrue("removed all matches", result.getMatchCount() == 0);
61
	61
62	62	for (int i= allMatches.size()-1; i >= 0; i--) {
63	63	result.addMatch(allMatches.get(i));
64	64	}
65
	65
66	66	assertEquals("Test that all matches have been added again", result.getMatchCount(), originalMatchCount);
67
	67
68	68	// now check that they're ordered by position.
69	69	for (int i= 0; i < elements.length; i++) {
70	70	Match[] matches= result.getMatches(elements[i]);

89	89	return false;
90	90	}
91	91	}
92
	92
93	93	}

+41

-0

org.eclipse.text/.settings/.api_filters less more

	0	<?xml version="1.0" encoding="UTF-8" standalone="no"?>
	1	<component id="org.eclipse.text" version="2">
	2	<resource path="src/org/eclipse/jface/text/Assert.java" type="org.eclipse.jface.text.Assert">
	3	<filter comment="Planned for deletion - Bug 528191 " id="338944126">
	4	<message_arguments>
	5	<message_argument value="org.eclipse.jface.text.Assert"/>
	6	<message_argument value="isLegal(boolean)"/>
	7	</message_arguments>
	8	</filter>
	9	<filter comment="Planned for deletion - Bug 528191 " id="338944126">
	10	<message_arguments>
	11	<message_argument value="org.eclipse.jface.text.Assert"/>
	12	<message_argument value="isLegal(boolean, String)"/>
	13	</message_arguments>
	14	</filter>
	15	<filter comment="Planned for deletion - Bug 528191 " id="338944126">
	16	<message_arguments>
	17	<message_argument value="org.eclipse.jface.text.Assert"/>
	18	<message_argument value="isNotNull(Object)"/>
	19	</message_arguments>
	20	</filter>
	21	<filter comment="Planned for deletion - Bug 528191 " id="338944126">
	22	<message_arguments>
	23	<message_argument value="org.eclipse.jface.text.Assert"/>
	24	<message_argument value="isNotNull(Object, String)"/>
	25	</message_arguments>
	26	</filter>
	27	<filter comment="Planned for deletion - Bug 528191 " id="338944126">
	28	<message_arguments>
	29	<message_argument value="org.eclipse.jface.text.Assert"/>
	30	<message_argument value="isTrue(boolean)"/>
	31	</message_arguments>
	32	</filter>
	33	<filter comment="Planned for deletion - Bug 528191 " id="338944126">
	34	<message_arguments>
	35	<message_argument value="org.eclipse.jface.text.Assert"/>
	36	<message_argument value="isTrue(boolean, String)"/>
	37	</message_arguments>
	38	</filter>
	39	</resource>
	40	</component>

+2

-1

org.eclipse.text/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %pluginName
3	3	Bundle-SymbolicName: org.eclipse.text
4		Bundle-Version: 3.6.100.qualifier
	4	Bundle-Version: 3.6.300.qualifier
5	5	Bundle-Vendor: %providerName
6	6	Bundle-Localization: plugin
7	7	Export-Package:

19	19	Import-Package:
20	20	com.ibm.icu.text,
21	21	com.ibm.icu.util
	22	Automatic-Module-Name: org.eclipse.text

+1

-0

org.eclipse.text/forceQualifierUpdate.txt less more

0	0	# To force a version qualifier update add the bug here
1	1	Bug 466364: Cannot run unit-tests anymore because classes from org.eclipse.jface.text cannot be loaded because of "signer information does not match signer information of other classes in the same package"
	2	Pick up new signing certificate

+2

-2

org.eclipse.text/pom.xml less more

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<groupId>org.eclipse.text</groupId>
19	19	<artifactId>org.eclipse.text</artifactId>
20		<version>3.6.100-SNAPSHOT</version>
	20	<version>3.6.300-SNAPSHOT</version>
21	21	<packaging>eclipse-plugin</packaging>
22	22	</project>

+1

-1

org.eclipse.text/projection/org/eclipse/jface/text/projection/ProjectionTextStore.java less more

127	127	public String get(int offset, int length) {
128	128	try {
129	129	IRegion[] fragments= fMapping.toExactOriginRegions(new Region(offset, length));
130		StringBuffer buffer= new StringBuffer();
	130	StringBuilder buffer= new StringBuilder();
131	131	for (int i= 0; i < fragments.length; i++) {
132	132	IRegion fragment= fragments[i];
133	133	buffer.append(fMasterDocument.get(fragment.getOffset(), fragment.getLength()));

+4

-5

org.eclipse.text/src/org/eclipse/jface/text/AbstractDocument.java less more

1527	1527	protected final void stopRewriteSessionOnPartitioners(DocumentRewriteSession session) {
1528	1528	if (fDocumentPartitioners != null) {
1529	1529	DocumentPartitioningChangedEvent event= new DocumentPartitioningChangedEvent(this);
1530		Iterator<String> e= fDocumentPartitioners.keySet().iterator();
1531		while (e.hasNext()) {
1532		String partitioning= e.next();
1533		IDocumentPartitioner partitioner= fDocumentPartitioners.get(partitioning);
	1530	for (Entry<String, IDocumentPartitioner> entry : fDocumentPartitioners.entrySet()) {
	1531	String partitioning = entry.getKey();
	1532	IDocumentPartitioner partitioner= entry.getValue();
1534	1533	if (partitioner instanceof IDocumentPartitionerExtension3) {
1535	1534	IDocumentPartitionerExtension3 extension= (IDocumentPartitionerExtension3) partitioner;
1536	1535	extension.stopRewriteSession(session);

1698	1697
1699	1698	/**
1700	1699	* Logs the given exception by reusing the code in {@link SafeRunner}.
1701		*
	1700	*
1702	1701	* @param ex the exception
1703	1702	* @since 3.6
1704	1703	*/

+3

-0

org.eclipse.text/src/org/eclipse/jface/text/Assert.java less more

29	29	*
30	30	* @deprecated As of 3.3, replaced by {@link org.eclipse.core.runtime.Assert}
31	31	* @noinstantiate This class is not intended to be instantiated by clients.
	32	*
	33	* @noreference This class is planned to be deleted, see Bug 528191
	34	*
32	35	*/
33	36	@Deprecated
34	37	public final class Assert {

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/CopyOnWriteTextStore.java less more

40	40
41	41	/** Represents the content of this text store. */
42	42	private final String fText;
43
	43
44	44	/** Minimum length limit below which {@link #get(int, int)} will return a String copy */
45	45	private final int fCopyLimit;
46	46

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/Document.java less more

35	35	* See {@link GapTextStore} and <code>TreeLineTracker</code> for algorithmic behavior of the used
36	36	* document structures.
37	37	* </p>
38		*
	38	*
39	39	* @see org.eclipse.jface.text.GapTextStore
40	40	* @see org.eclipse.jface.text.CopyOnWriteTextStore
41	41	*/

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/DocumentEvent.java less more

130	130
131	131	@Override
132	132	public String toString() {
133		StringBuffer buffer= new StringBuffer();
	133	StringBuilder buffer= new StringBuilder();
134	134	buffer.append("offset: " ); //$NON-NLS-1$
135	135	buffer.append(fOffset);
136	136	buffer.append(", length: " ); //$NON-NLS-1$

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/DocumentRewriteSession.java less more

42	42
43	43	@Override
44	44	public String toString() {
45		return new StringBuffer().append(hashCode()).toString();
	45	return new StringBuilder().append(hashCode()).toString();
46	46	}
47	47	}

+16

-12

org.eclipse.text/src/org/eclipse/jface/text/FindReplaceDocumentAdapter.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2012 IBM Corporation and others.
	1	* Copyright (c) 2000, 2017 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

8	8	* IBM Corporation - initial API and implementation
9	9	* Cagatay Calli <ccalli@gmail.com> - [find/replace] retain caps when replacing - https://bugs.eclipse.org/bugs/show_bug.cgi?id=28949
10	10	* Cagatay Calli <ccalli@gmail.com> - [find/replace] define & fix behavior of retain caps with other escapes and text before \C - https://bugs.eclipse.org/bugs/show_bug.cgi?id=217061
	11	* Florian Ingerl <imelflorianingerl@gmail.com> - [find/replace] replace doesn't work when using a regex with a lookahead or boundary matchers - https://bugs.eclipse.org/bugs/show_bug.cgi?id=109481
11	12	*******************************************************************************/
12	13	package org.eclipse.jface.text;
13	14

193	194	String prevMatch= fFindReplaceMatcher.group();
194	195	try {
195	196	replaceText= interpretReplaceEscapes(replaceText, prevMatch);
196		Matcher replaceTextMatcher= pattern.matcher(prevMatch);
197		replaceText= replaceTextMatcher.replaceFirst(replaceText);
	197	Matcher replaceTextMatcher= pattern.matcher(this);
	198	replaceTextMatcher.find(fFindReplaceMatcher.start());
	199	StringBuffer sb= new StringBuffer();
	200	replaceTextMatcher.appendReplacement(sb, replaceText);
	201	replaceText= sb.substring(fFindReplaceMatcher.start());
198	202	} catch (IndexOutOfBoundsException ex) {
199	203	throw new PatternSyntaxException(ex.getLocalizedMessage(), replaceText, -1);
200	204	}

268	272	*/
269	273	private String substituteLinebreak(String findString) throws PatternSyntaxException {
270	274	int length= findString.length();
271		StringBuffer buf= new StringBuffer(length);
	275	StringBuilder buf= new StringBuilder(length);
272	276
273	277	int inCharGroup= 0;
274	278	int inBraces= 0;

346	350	* @param ch the character to process
347	351	* @since 3.4
348	352	*/
349		private void interpretRetainCase(StringBuffer buf, char ch) {
	353	private void interpretRetainCase(StringBuilder buf, char ch) {
350	354	if (fRetainCaseMode == RC_UPPER)
351	355	buf.append(String.valueOf(ch).toUpperCase());
352	356	else if (fRetainCaseMode == RC_LOWER)

369	373	private String interpretReplaceEscapes(String replaceText, String foundText) {
370	374	int length= replaceText.length();
371	375	boolean inEscape= false;
372		StringBuffer buf= new StringBuffer(length);
	376	StringBuilder buf= new StringBuilder(length);
373	377
374	378	/* every string we did not check looks mixed at first
375	379	* so initialize retain case mode with RC_MIXED

430	434	* @return the new offset
431	435	* @since 3.4
432	436	*/
433		private int interpretReplaceEscape(final char ch, int i, StringBuffer buf, String replaceText, String foundText) {
	437	private int interpretReplaceEscape(final char ch, int i, StringBuilder buf, String replaceText, String foundText) {
434	438	int length= replaceText.length();
435	439	switch (ch) {
436	440	case 'r':

560	564	* @return the string converted to a regex pattern
561	565	*/
562	566	private String asRegPattern(String string) {
563		StringBuffer out= new StringBuffer(string.length());
	567	StringBuilder out= new StringBuilder(string.length());
564	568	boolean quoting= false;
565	569
566	570	for (int i= 0, length= string.length(); i < length; i++) {

643	647	*/
644	648	public static String escapeForRegExPattern(String string) {
645	649	//implements https://bugs.eclipse.org/bugs/show_bug.cgi?id=44422
646
647		StringBuffer pattern= new StringBuffer(string.length() + 16);
	650
	651	StringBuilder pattern= new StringBuilder(string.length() + 16);
648	652	int length= string.length();
649	653	for (int i= 0; i < length; i++) {
650	654	char ch= string.charAt(i);

665	669	case '$':
666	670	pattern.append('\\').append(ch);
667	671	break;
668
	672
669	673	case '\r':
670	674	if (i + 1 < length && string.charAt(i + 1) == '\n')
671	675	i++;

685	689	case 0x1B:
686	690	pattern.append("\\e"); //$NON-NLS-1$
687	691	break;
688
	692
689	693	default:
690	694	if (0 <= ch && ch < 0x20) {
691	695	pattern.append("\\x"); //$NON-NLS-1$

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/GapTextStore.java less more

155	155	if (end <= fGapStart)
156	156	return new String(fContent, offset, length);
157	157
158		StringBuffer buf= new StringBuffer(length);
	158	StringBuilder buf= new StringBuilder(length); // see Bug 113871
159	159	buf.append(fContent, offset, fGapStart - offset);
160	160	buf.append(fContent, fGapEnd, end - fGapStart);
161	161	return buf.toString();

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/IDocument.java less more

587	587	* <p>
588	588	* Note that a document always has at least one line.
589	589	* </p>
590		*
	590	*
591	591	* @return the number of lines in this document.
592	592	*/
593	593	int getNumberOfLines();

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/ILineTracker.java less more

64	64	* <p>
65	65	* Note that a document always has at least one line.
66	66	* </p>
67		*
	67	*
68	68	* @return the number of lines in this tracker's line structure
69	69	*/
70	70	int getNumberOfLines();

+2

-2

org.eclipse.text/src/org/eclipse/jface/text/IRepairableDocumentExtension.java less more

15	15	* <p>
16	16	* Adds the ability to query whether the repairable document would have to be repaired after
17	17	* replacing some text.
18		*
	18	*
19	19	* @see org.eclipse.jface.text.IRepairableDocument
20	20	* @since 3.4
21	21	*/

24	24	/**
25	25	* Tells whether the line information of the document implementing this interface needs to be
26	26	* repaired after replacing the given text.
27		*
	27	*
28	28	* @param offset the document offset
29	29	* @param length the length of the specified range
30	30	* @param text the substitution text to check

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/ISlaveDocumentManager.java less more

95	95	* contain the lines 8-20.
96	96	* <p>
97	97	* This call is without effect if the given document is unknown to this slave document manager.
98		*
	98	*
99	99	* @param slave the slave whose auto expand mode should be set
100	100	* @param autoExpand <code>true</code> for auto expand, <code>false</code> otherwise
101	101	*/

+6

-3

org.eclipse.text/src/org/eclipse/jface/text/ListLineTracker.java less more

131	131
132	132	@Override
133	133	public final int getLineNumberOfOffset(int position) throws BadLocationException {
134		if (position < 0 \|\| position > fTextLength)
135		throw new BadLocationException();
	134	if (position < 0) {
	135	throw new BadLocationException("Negative offset : " + position); //$NON-NLS-1$
	136	} else if (position > fTextLength) {
	137	throw new BadLocationException("Offset > length: " + position + " > " + fTextLength); //$NON-NLS-1$//$NON-NLS-2$
	138	}
136	139
137	140	if (position == fTextLength) {
138	141

150	153	@Override
151	154	public final IRegion getLineInformationOfOffset(int position) throws BadLocationException {
152	155	if (position > fTextLength)
153		throw new BadLocationException();
	156	throw new BadLocationException("Offset > length: " + position + " > " + fTextLength); //$NON-NLS-1$//$NON-NLS-2$
154	157
155	158	if (position == fTextLength) {
156	159	int size= fLines.size();

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/Position.java less more

190	190	Assert.isTrue(offset >= 0);
191	191	this.offset= offset;
192	192	}
193
	193
194	194	@Override
195	195	public String toString() {
196	196	String position= "offset: " + offset + ", length: " + length; //$NON-NLS-1$//$NON-NLS-2$

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/SequentialRewriteTextStore.java less more

234	234	if (fReplaceList.isEmpty())
235	235	return;
236	236
237		StringBuffer buffer= new StringBuffer();
	237	StringBuilder buffer= new StringBuilder();
238	238
239	239	int delta= 0;
240	240	for (Replace replace : fReplaceList) {

+5

-5

org.eclipse.text/src/org/eclipse/jface/text/TextUtilities.java less more

15	15	import java.util.List;
16	16	import java.util.ListIterator;
17	17	import java.util.Map;
	18	import java.util.Map.Entry;
18	19	import java.util.Set;
19	20
20	21	import org.eclipse.core.runtime.Assert;

193	194	final IDocument document= unprocessedDocument;
194	195	int offset= firstEvent.getOffset();
195	196	int length= firstEvent.getLength();
196		final StringBuffer text= new StringBuffer(firstEvent.getText() == null ? "" : firstEvent.getText()); //$NON-NLS-1$
	197	final StringBuilder text= new StringBuilder(firstEvent.getText() == null ? "" : firstEvent.getText()); //$NON-NLS-1$
197	198
198	199	while (iterator.hasNext()) {
199	200

339	340	public static void addDocumentPartitioners(IDocument document, Map<String, ? extends IDocumentPartitioner> partitioners) {
340	341	if (document instanceof IDocumentExtension3) {
341	342	IDocumentExtension3 extension3= (IDocumentExtension3) document;
342		Iterator<String> e= partitioners.keySet().iterator();
343		while (e.hasNext()) {
344		String partitioning= e.next();
345		IDocumentPartitioner partitioner= partitioners.get(partitioning);
	343	for (Entry<String, ? extends IDocumentPartitioner> entry : partitioners.entrySet()) {
	344	String partitioning= entry.getKey();
	345	IDocumentPartitioner partitioner= entry.getValue();
346	346	partitioner.connect(document);
347	347	extension3.setDocumentPartitioner(partitioning, partitioner);
348	348	}

+1

-1

org.eclipse.text/src/org/eclipse/jface/text/TreeLineTracker.java less more

1230	1230
1231	1231	List<Node> roots= new LinkedList<>();
1232	1232	roots.add(fRoot);
1233		StringBuffer buf= new StringBuffer((width + 1) * depth);
	1233	StringBuilder buf= new StringBuilder((width + 1) * depth); // see Bug 137688
1234	1234	int indents= leaves;
1235	1235	char[] space= new char[leaves * WIDTH / 2];
1236	1236	Arrays.fill(space, ' ');

+2

-3

org.eclipse.text/src/org/eclipse/jface/text/link/LinkedModeManager.java less more

165	165	}
166	166
167	167	private void removeManager() {
168		for (Iterator<IDocument> it= fgManagers.keySet().iterator(); it.hasNext();) {
169		IDocument doc= it.next();
170		if (fgManagers.get(doc) == this)
	168	for (Iterator<LinkedModeManager> it= fgManagers.values().iterator(); it.hasNext();) {
	169	if (it.next() == this)
171	170	it.remove();
172	171	}
173	172	}

+4

-2

org.eclipse.text/src/org/eclipse/jface/text/link/LinkedModeModel.java less more

14	14	import java.util.HashSet;
15	15	import java.util.List;
16	16	import java.util.Map;
	17	import java.util.Map.Entry;
17	18	import java.util.Set;
18	19
19	20	import org.eclipse.core.runtime.Assert;

220	221
221	222	if (result != null) {
222	223	// edit all documents
223		for (IDocument doc : result.keySet()) {
224		TextEdit edit= result.get(doc);
	224	for (Entry<IDocument, TextEdit> entry : result.entrySet()) {
	225	IDocument doc = entry.getKey();
	226	TextEdit edit= entry.getValue();
225	227	Replace replace= new Replace(edit);
226	228
227	229	// apply the edition, either as post notification replace

+6

-5

org.eclipse.text/src/org/eclipse/jface/text/link/LinkedPositionGroup.java less more

15	15	import java.util.LinkedList;
16	16	import java.util.List;
17	17	import java.util.Map;
	18	import java.util.Map.Entry;
18	19
19	20	import org.eclipse.core.runtime.Assert;
20	21

80	81	* change.
81	82	*/
82	83	private IRegion fLastRegion;
83
	84
84	85	/**
85	86	* <code>true</code> iff not all positions contain the same content.
86	87	* In that case, the contents of the last edited position will replace the

270	271
271	272	try {
272	273	Map<IDocument, TextEdit> result= new HashMap<>();
273		for (IDocument d : map.keySet()) {
274		TextEdit edit= new MultiTextEdit(0, d.getLength());
275		edit.addChildren(map.get(d).toArray(new TextEdit[0]));
276		result.put(d, edit);
	274	for (Entry<IDocument, List<ReplaceEdit>> edits : map.entrySet()) {
	275	TextEdit edit= new MultiTextEdit(0, edits.getKey().getLength());
	276	edit.addChildren(edits.getValue().toArray(new TextEdit[edits.getValue().size()]));
	277	result.put(edits.getKey(), edit);
277	278	}
278	279
279	280	return result;

+3

-5

org.eclipse.text/src/org/eclipse/jface/text/source/AnnotationModel.java less more

183	183
184	184	/**
185	185	* A single iterator builds its behavior based on a sequence of iterators.
186		*
	186	*
187	187	* @param <E> the type of elements returned by this iterator
188	188	* @since 3.1
189	189	*/

492	492	connected();
493	493	}
494	494
495		for (Object object : fAttachments.keySet()) {
496		IAnnotationModel model= fAttachments.get(object);
	495	for (IAnnotationModel model : fAttachments.values()) {
497	496	model.connect(document);
498	497	}
499	498	}

517	516
518	517	Assert.isTrue(fDocument == document);
519	518
520		for (Object object : fAttachments.keySet()) {
521		IAnnotationModel model= fAttachments.get(object);
	519	for (IAnnotationModel model : fAttachments.values()) {
522	520	model.disconnect(document);
523	521	}
524	522

+2

-2

org.eclipse.text/src/org/eclipse/jface/text/templates/GlobalTemplateVariables.java less more

51	51
52	52	/**
53	53	* The selection variable determines templates that work on a selection.
54		*
	54	*
55	55	* @since 3.6
56	56	*/
57	57	public static class Selection extends SimpleTemplateVariableResolver {
58	58
59	59	/**
60	60	* Creates a word selection variable.
61		*
	61	*
62	62	* @param name the name of the variable
63	63	* @param description the description of the variable
64	64	*/

+2

-2

org.eclipse.text/src/org/eclipse/jface/text/templates/TemplateTranslator.java less more

43	43	public class TemplateTranslator {
44	44	/**
45	45	* Regex pattern for identifier.
46		* Note: For historic reasons, this pattern <em>allows</em> numbers at the beginning of an identifier.
	46	* Note: For historic reasons, this pattern <em>allows</em> numbers at the beginning of an identifier.
47	47	* @since 3.7
48	48	*/
49	49	private static final String IDENTIFIER= "(?:[\\p{javaJavaIdentifierPart}&&[^\\$]]++)"; //$NON-NLS-1$

183	183	private TemplateBuffer parse(String string) throws TemplateException {
184	184
185	185	fErrorMessage= null;
186		final StringBuffer buffer= new StringBuffer(string.length());
	186	final StringBuilder buffer= new StringBuilder(string.length());
187	187	final Matcher matcher= ESCAPE_PATTERN.matcher(string);
188	188	final Map<String, VariableDescription> variables= new LinkedHashMap<>();
189	189

+0

-12

org.eclipse.text/src/org/eclipse/text/edits/CopySourceEdit.java less more

169	169	fModifier= modifier;
170	170	}
171	171
172		/*
173		* @see TextEdit#doCopy
174		*/
175	172	@Override
176	173	protected TextEdit doCopy() {
177	174	return new CopySourceEdit(this);
178	175	}
179	176
180		/*
181		* @see TextEdit#accept0
182		*/
183	177	@Override
184	178	protected void accept0(TextEditVisitor visitor) {
185	179	boolean visitChildren= visitor.visit(this);

203	197	fSourceContent= null;
204	198	}
205	199
206		/*
207		* @see TextEdit#postProcessCopy
208		*/
209	200	@Override
210	201	protected void postProcessCopy(TextEditCopier copier) {
211	202	if (fTarget != null) {

320	311
321	312	//---- region updating ----------------------------------------------------------------
322	313
323		/*
324		* @see TextEdit#deleteChildren
325		*/
326	314	@Override
327	315	boolean deleteChildren() {
328	316	return false;

+0

-21

org.eclipse.text/src/org/eclipse/text/edits/CopyTargetEdit.java less more

95	95	}
96	96	}
97	97
98		/*
99		* @see TextEdit#doCopy
100		*/
101	98	@Override
102	99	protected TextEdit doCopy() {
103	100	return new CopyTargetEdit(this);
104	101	}
105	102
106		/*
107		* @see TextEdit#postProcessCopy
108		*/
109	103	@Override
110	104	protected void postProcessCopy(TextEditCopier copier) {
111	105	if (fSource != null) {

116	110	}
117	111	}
118	112
119		/*
120		* @see TextEdit#accept0
121		*/
122	113	@Override
123	114	protected void accept0(TextEditVisitor visitor) {
124	115	boolean visitChildren= visitor.visit(this);

127	118	}
128	119	}
129	120
130		/*
131		* @see TextEdit#traverseConsistencyCheck
132		*/
133	121	@Override
134	122	int traverseConsistencyCheck(TextEditProcessor processor, IDocument document, List<List<TextEdit>> sourceEdits) {
135	123	return super.traverseConsistencyCheck(processor, document, sourceEdits) + 1;
136	124	}
137	125
138		/*
139		* @see TextEdit#performConsistencyCheck
140		*/
141	126	@Override
142	127	void performConsistencyCheck(TextEditProcessor processor, IDocument document) throws MalformedTreeException {
143	128	if (fSource == null)

146	131	throw new MalformedTreeException(getParent(), this, TextEditMessages.getString("CopyTargetEdit.different_target")); //$NON-NLS-1$
147	132	}
148	133
149		/*
150		* @see TextEdit#performDocumentUpdating
151		*/
152	134	@Override
153	135	int performDocumentUpdating(IDocument document) throws BadLocationException {
154	136	String source= fSource.getContent();

158	140	return fDelta;
159	141	}
160	142
161		/*
162		* @see TextEdit#deleteChildren
163		*/
164	143	@Override
165	144	boolean deleteChildren() {
166	145	return false;

+0

-12

org.eclipse.text/src/org/eclipse/text/edits/CopyingRangeMarker.java less more

42	42	fText= other.fText;
43	43	}
44	44
45		/*
46		* @see TextEdit#doCopy
47		*/
48	45	@Override
49	46	protected TextEdit doCopy() {
50	47	return new CopyingRangeMarker(this);
51	48	}
52	49
53		/*
54		* @see TextEdit#accept0
55		*/
56	50	@Override
57	51	protected void accept0(TextEditVisitor visitor) {
58	52	boolean visitChildren= visitor.visit(this);

61	55	}
62	56	}
63	57
64		/*
65		* @see TextEdit#performDocumentUpdating
66		*/
67	58	@Override
68	59	int performDocumentUpdating(IDocument document) throws BadLocationException {
69	60	fText= document.get(getOffset(), getLength());

71	62	return fDelta;
72	63	}
73	64
74		/*
75		* @see TextEdit#deleteChildren
76		*/
77	65	@Override
78	66	boolean deleteChildren() {
79	67	return false;

+0

-12

org.eclipse.text/src/org/eclipse/text/edits/DeleteEdit.java less more

39	39	super(other);
40	40	}
41	41
42		/*
43		* @see TextEdit#doCopy
44		*/
45	42	@Override
46	43	protected TextEdit doCopy() {
47	44	return new DeleteEdit(this);
48	45	}
49	46
50		/*
51		* @see TextEdit#accept0
52		*/
53	47	@Override
54	48	protected void accept0(TextEditVisitor visitor) {
55	49	boolean visitChildren= visitor.visit(this);

58	52	}
59	53	}
60	54
61		/*
62		* @see TextEdit#performDocumentUpdating
63		*/
64	55	@Override
65	56	int performDocumentUpdating(IDocument document) throws BadLocationException {
66	57	document.replace(getOffset(), getLength(), ""); //$NON-NLS-1$

68	59	return fDelta;
69	60	}
70	61
71		/*
72		* @see TextEdit#deleteChildren
73		*/
74	62	@Override
75	63	boolean deleteChildren() {
76	64	return true;

+2

-2

org.eclipse.text/src/org/eclipse/text/edits/EditDocument.java less more

23	23
24	24	class EditDocument implements IDocument {
25	25
26		private StringBuffer fBuffer;
	26	private StringBuilder fBuffer;
27	27
28	28	public EditDocument(String content) {
29		fBuffer= new StringBuffer(content);
	29	fBuffer= new StringBuilder(content);
30	30	}
31	31
32	32	@Override

+1

-13

org.eclipse.text/src/org/eclipse/text/edits/InsertEdit.java less more

56	56	return fText;
57	57	}
58	58
59		/*
60		* @see TextEdit#doCopy
61		*/
62	59	@Override
63	60	protected TextEdit doCopy() {
64	61	return new InsertEdit(this);
65	62	}
66	63
67		/*
68		* @see TextEdit#accept0
69		*/
70	64	@Override
71	65	protected void accept0(TextEditVisitor visitor) {
72	66	boolean visitChildren= visitor.visit(this);

75	69	}
76	70	}
77	71
78		/*
79		* @see TextEdit#performDocumentUpdating
80		*/
81	72	@Override
82	73	int performDocumentUpdating(IDocument document) throws BadLocationException {
83	74	document.replace(getOffset(), getLength(), fText);

85	76	return fDelta;
86	77	}
87	78
88		/*
89		* @see TextEdit#deleteChildren
90		*/
91	79	@Override
92	80	boolean deleteChildren() {
93	81	return false;
94	82	}
95	83
96	84	@Override
97		void internalToString(StringBuffer buffer, int indent) {
	85	void internalToString(StringBuilder buffer, int indent) {
98	86	super.internalToString(buffer, indent);
99	87	buffer.append(" <<").append(fText); //$NON-NLS-1$
100	88	}

+0

-12

org.eclipse.text/src/org/eclipse/text/edits/MoveSourceEdit.java less more

145	145
146	146	//---- Copying -------------------------------------------------------------
147	147
148		/*
149		* @see TextEdit#doCopy
150		*/
151	148	@Override
152	149	protected TextEdit doCopy() {
153	150	return new MoveSourceEdit(this);
154	151	}
155	152
156		/*
157		* @see TextEdit#postProcessCopy
158		*/
159	153	@Override
160	154	protected void postProcessCopy(TextEditCopier copier) {
161	155	if (fTarget != null) {

168	162
169	163	//---- Visitor -------------------------------------------------------------
170	164
171		/*
172		* @see TextEdit#accept0
173		*/
174	165	@Override
175	166	protected void accept0(TextEditVisitor visitor) {
176	167	boolean visitChildren= visitor.visit(this);

275	266
276	267	//---- region updating --------------------------------------------------------------
277	268
278		/*
279		* @see TextEdit#deleteChildren
280		*/
281	269	@Override
282	270	boolean deleteChildren() {
283	271	return false;

+0

-18

org.eclipse.text/src/org/eclipse/text/edits/MoveTargetEdit.java less more

94	94	}
95	95	}
96	96
97		/*
98		* @see TextEdit#doCopy
99		*/
100	97	@Override
101	98	protected TextEdit doCopy() {
102	99	return new MoveTargetEdit(this);
103	100	}
104	101
105		/*
106		* @see TextEdit#postProcessCopy
107		*/
108	102	@Override
109	103	protected void postProcessCopy(TextEditCopier copier) {
110	104	if (fSource != null) {

115	109	}
116	110	}
117	111
118		/*
119		* @see TextEdit#accept0
120		*/
121	112	@Override
122	113	protected void accept0(TextEditVisitor visitor) {
123	114	boolean visitChildren= visitor.visit(this);

128	119
129	120	//---- consistency check ----------------------------------------------------------
130	121
131		/*
132		* @see TextEdit#traverseConsistencyCheck
133		*/
134	122	@Override
135	123	int traverseConsistencyCheck(TextEditProcessor processor, IDocument document, List<List<TextEdit>> sourceEdits) {
136	124	return super.traverseConsistencyCheck(processor, document, sourceEdits) + 1;
137	125	}
138	126
139		/*
140		* @see TextEdit#performConsistencyCheck
141		*/
142	127	@Override
143	128	void performConsistencyCheck(TextEditProcessor processor, IDocument document) throws MalformedTreeException {
144	129	if (fSource == null)

175	160
176	161	//---- region updating --------------------------------------------------------------
177	162
178		/*
179		* @see org.eclipse.text.edits.TextEdit#traversePassThree
180		*/
181	163	@Override
182	164	int traverseRegionUpdating(TextEditProcessor processor, IDocument document, int accumulatedDelta, boolean delete) {
183	165	// the children got already updated / normalized while they got removed

+1

-16

org.eclipse.text/src/org/eclipse/text/edits/MultiTextEdit.java less more

131	131	return true;
132	132	}
133	133
134		/*
135		* @see TextEdit#copy
136		*/
137	134	@Override
138	135	protected TextEdit doCopy() {
139	136	Assert.isTrue(MultiTextEdit.class == getClass(), "Subclasses must reimplement copy0"); //$NON-NLS-1$
140	137	return new MultiTextEdit(this);
141	138	}
142	139
143		/*
144		* @see TextEdit#accept0
145		*/
146	140	@Override
147	141	protected void accept0(TextEditVisitor visitor) {
148	142	boolean visitChildren= visitor.visit(this);

163	157	super.adjustLength(delta);
164	158	}
165	159
166		/*
167		* @see TextEdit#performConsistencyCheck
168		*/
169	160	@Override
170	161	void performConsistencyCheck(TextEditProcessor processor, IDocument document) throws MalformedTreeException {
171	162	checkIntegrity();
172	163	}
173	164
174		/*
175		* @see TextEdit#performDocumentUpdating
176		*/
177	165	@Override
178	166	int performDocumentUpdating(IDocument document) throws BadLocationException {
179	167	fDelta= 0;
180	168	return fDelta;
181	169	}
182	170
183		/*
184		* @see TextEdit#deleteChildren
185		*/
186	171	@Override
187	172	boolean deleteChildren() {
188	173	return false;

208	193	}
209	194
210	195	@Override
211		void internalToString(StringBuffer buffer, int indent) {
	196	void internalToString(StringBuilder buffer, int indent) {
212	197	super.internalToString(buffer, indent);
213	198	if (! fDefined)
214	199	buffer.append(" [undefined]"); //$NON-NLS-1$

+0

-12

org.eclipse.text/src/org/eclipse/text/edits/RangeMarker.java less more

37	37	super(other);
38	38	}
39	39
40		/*
41		* @see TextEdit#copy
42		*/
43	40	@Override
44	41	protected TextEdit doCopy() {
45	42	return new RangeMarker(this);
46	43	}
47	44
48		/*
49		* @see TextEdit#accept0
50		*/
51	45	@Override
52	46	protected void accept0(TextEditVisitor visitor) {
53	47	boolean visitChildren= visitor.visit(this);

56	50	}
57	51	}
58	52
59		/*
60		* @see TextEdit#performDocumentUpdating
61		*/
62	53	@Override
63	54	int performDocumentUpdating(IDocument document) throws BadLocationException {
64	55	fDelta= 0;
65	56	return fDelta;
66	57	}
67	58
68		/*
69		* @see TextEdit#deleteChildren
70		*/
71	59	@Override
72	60	boolean deleteChildren() {
73	61	return false;

+1

-13

org.eclipse.text/src/org/eclipse/text/edits/ReplaceEdit.java less more

57	57	return fText;
58	58	}
59	59
60		/*
61		* @see TextEdit#doCopy
62		*/
63	60	@Override
64	61	protected TextEdit doCopy() {
65	62	return new ReplaceEdit(this);
66	63	}
67	64
68		/*
69		* @see TextEdit#accept0
70		*/
71	65	@Override
72	66	protected void accept0(TextEditVisitor visitor) {
73	67	boolean visitChildren= visitor.visit(this);

76	70	}
77	71	}
78	72
79		/*
80		* @see TextEdit#performDocumentUpdating
81		*/
82	73	@Override
83	74	int performDocumentUpdating(IDocument document) throws BadLocationException {
84	75	document.replace(getOffset(), getLength(), fText);

86	77	return fDelta;
87	78	}
88	79
89		/*
90		* @see TextEdit#deleteChildren
91		*/
92	80	@Override
93	81	boolean deleteChildren() {
94	82	return true;
95	83	}
96	84
97	85	@Override
98		void internalToString(StringBuffer buffer, int indent) {
	86	void internalToString(StringBuilder buffer, int indent) {
99	87	super.internalToString(buffer, indent);
100	88	buffer.append(" <<").append(fText); //$NON-NLS-1$
101	89	}

+9

-9

org.eclipse.text/src/org/eclipse/text/edits/TextEdit.java less more

513	513
514	514	@Override
515	515	public String toString() {
516		StringBuffer buffer= new StringBuffer();
	516	StringBuilder buffer= new StringBuilder();
517	517	toStringWithChildren(buffer, 0);
518	518	return buffer.toString();
519	519	}
520	520
521	521	/**
522	522	* Adds the string representation of this text edit without
523		* children information to the given string buffer.
524		*
525		* @param buffer the string buffer
	523	* children information to the given string builder.
	524	*
	525	* @param buffer the string builder
526	526	* @param indent the indent level in number of spaces
527	527	* @since 3.3
528	528	*/
529		void internalToString(StringBuffer buffer, int indent) {
	529	void internalToString(StringBuilder buffer, int indent) {
530	530	for (int i= indent; i > 0; i--) {
531	531	buffer.append(" "); //$NON-NLS-1$
532	532	}

552	552
553	553	/**
554	554	* Adds the string representation for this text edit
555		* and its children to the given string buffer.
556		*
557		* @param buffer the string buffer
	555	* and its children to the given string builder.
	556	*
	557	* @param buffer the string builder
558	558	* @param indent the indent level in number of spaces
559	559	* @since 3.3
560	560	*/
561		private void toStringWithChildren(StringBuffer buffer, int indent) {
	561	private void toStringWithChildren(StringBuilder buffer, int indent) {
562	562	internalToString(buffer, indent);
563	563	if (fChildren != null) {
564	564	for (TextEdit child : fChildren) {

+0

-6

org.eclipse.text/src/org/eclipse/text/edits/UndoEdit.java less more

63	63	return new UndoEdit(this);
64	64	}
65	65
66		/*
67		* @see TextEdit#accept0
68		*/
69	66	@Override
70	67	protected void accept0(TextEditVisitor visitor) {
71	68	boolean visitChildren= visitor.visit(this);

74	71	}
75	72	}
76	73
77		/*
78		* @see TextEdit#performDocumentUpdating
79		*/
80	74	@Override
81	75	int performDocumentUpdating(IDocument document) throws BadLocationException {
82	76	fDelta= 0;

+5

-5

org.eclipse.text/src/org/eclipse/text/undo/DocumentUndoManager.java less more

371	371	@Override
372	372	public String toString() {
373	373	String delimiter= ", "; //$NON-NLS-1$
374		StringBuffer text= new StringBuffer(super.toString());
	374	StringBuilder text= new StringBuilder(super.toString());
375	375	text.append("\n"); //$NON-NLS-1$
376	376	text.append(this.getClass().getName());
377	377	text.append(" undo modification stamp: "); //$NON-NLS-1$

710	710	/**
711	711	* Text buffer to collect viewer content which has been replaced
712	712	*/
713		private StringBuffer fPreservedTextBuffer;
	713	private StringBuilder fPreservedTextBuffer;
714	714
715	715	/**
716	716	* The document modification stamp for undo.

725	725	/**
726	726	* Text buffer to collect text which is inserted into the viewer
727	727	*/
728		private StringBuffer fTextBuffer;
	728	private StringBuilder fTextBuffer;
729	729
730	730	/** Indicates inserting state. */
731	731	private boolean fInserting= false;

1141	1141	// open up the current text edit
1142	1142	fCurrent= new UndoableTextChange(this);
1143	1143	fPreviousDelete= new UndoableTextChange(this);
1144		fTextBuffer= new StringBuffer();
1145		fPreservedTextBuffer= new StringBuffer();
	1144	fTextBuffer= new StringBuilder();
	1145	fPreservedTextBuffer= new StringBuilder();
1146	1146
1147	1147	addListeners();
1148	1148	}

+12

-8

org.eclipse.text.releng/platformText.setup less more

53	53	name="*"/>
54	54	<sourceLocator
55	55	rootFolder="${git.clone.platform.text.location}"
56		locateNestedProjects="true"/>
	56	locateNestedProjects="true">
	57	<predicate
	58	xsi:type="predicates:NotPredicate">
	59	<operand
	60	xsi:type="predicates:AndPredicate">
	61	<operand
	62	xsi:type="predicates:NamePredicate"
	63	pattern="eclipse\.platform\.text"/>
	64	</operand>
	65	</predicate>
	66	</sourceLocator>
57	67	</targlet>
58	68	</setupTask>
59	69	<setupTask

96	106	</workingSet>
97	107	</setupTask>
98	108	<stream name="master"
99		label="Master">
100		<setupTask
101		xsi:type="setup:VariableTask"
102		name="eclipse.target.platform"
103		value="Oxygen"
104		storageURI="scope://Workspace"/>
105		</stream>
	109	label="Master"/>
106	110	<logicalProjectContainer
107	111	xsi:type="setup:Project"
108	112	href="index:/org.eclipse.setup#//@projectCatalogs[name='org.eclipse']/@projects[name='platform']"/>

+21

-20

org.eclipse.text.tests/META-INF/MANIFEST.MF less more

0		Manifest-Version: 1.0
1		Bundle-ManifestVersion: 2
2		Bundle-Name: %Plugin.name
3		Bundle-SymbolicName: org.eclipse.text.tests
4		Bundle-Version: 3.11.0.qualifier
5		Bundle-Vendor: %Plugin.providerName
6		Bundle-Localization: plugin
7		Export-Package:
8		org.eclipse.text.tests,
9		org.eclipse.text.tests.link,
10		org.eclipse.text.tests.templates
11		Require-Bundle:
12		org.eclipse.core.commands;bundle-version="[3.5.0,4.0.0)",
13		org.eclipse.core.runtime;bundle-version="[3.5.0,4.0.0)",
14		org.eclipse.text;bundle-version="[3.5.0,4.0.0)",
15		org.junit;bundle-version="4.12.0"
16		Bundle-RequiredExecutionEnvironment: JavaSE-1.8
17		Eclipse-BundleShape: dir
18		Import-Package: com.ibm.icu.text,
19		com.ibm.icu.util
	0	Manifest-Version: 1.0
	1	Bundle-ManifestVersion: 2
	2	Bundle-Name: %Plugin.name
	3	Bundle-SymbolicName: org.eclipse.text.tests
	4	Bundle-Version: 3.12.0.qualifier
	5	Bundle-Vendor: %Plugin.providerName
	6	Bundle-Localization: plugin
	7	Export-Package:
	8	org.eclipse.text.tests,
	9	org.eclipse.text.tests.link,
	10	org.eclipse.text.tests.templates
	11	Require-Bundle:
	12	org.eclipse.core.commands;bundle-version="[3.5.0,4.0.0)",
	13	org.eclipse.core.runtime;bundle-version="[3.5.0,4.0.0)",
	14	org.eclipse.text;bundle-version="[3.6.3,4.0.0)",
	15	org.junit;bundle-version="4.12.0"
	16	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
	17	Eclipse-BundleShape: dir
	18	Import-Package: com.ibm.icu.text,
	19	com.ibm.icu.util
	20	Automatic-Module-Name: org.eclipse.text.tests

+2

-2

org.eclipse.text.tests/pom.xml less more

13	13	<parent>
14	14	<artifactId>tests-pom</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	<relativePath>../tests-pom/</relativePath>
18	18	</parent>
19	19	<groupId>org.eclipse.text</groupId>
20	20	<artifactId>org.eclipse.text.tests</artifactId>
21		<version>3.11.0-SNAPSHOT</version>
	21	<version>3.12.0-SNAPSHOT</version>
22	22	<packaging>eclipse-test-plugin</packaging>
23	23	<properties>
24	24	<testSuite>${project.artifactId}</testSuite>

+14

-48

org.eclipse.text.tests/src/org/eclipse/text/tests/Accessor.java less more

63	63	fInstance= instance;
64	64	try {
65	65	fClass= Class.forName(className, true, classLoader);
66		} catch (ClassNotFoundException e) {
67		fail(e);
68		} catch (ExceptionInInitializerError e) {
	66	} catch (ClassNotFoundException \| ExceptionInInitializerError e) {
69	67	fail(e);
70	68	}
71	69	}

97	95	public Accessor(String className, ClassLoader classLoader, Class<?>[] constructorTypes, Object[] constructorArgs) {
98	96	try {
99	97	fClass= Class.forName(className, true, classLoader);
100		} catch (ClassNotFoundException e) {
101		fail(e);
102		} catch (ExceptionInInitializerError e) {
	98	} catch (ClassNotFoundException \| ExceptionInInitializerError e) {
103	99	fail(e);
104	100	}
105	101	Constructor<?> constructor= null;
106	102	try {
107	103	constructor= fClass.getDeclaredConstructor(constructorTypes);
108		} catch (SecurityException e) {
109		fail(e);
110		} catch (NoSuchMethodException e) {
	104	} catch (SecurityException \| NoSuchMethodException e) {
111	105	fail(e);
112	106	}
113	107	Assert.isNotNull(constructor);
114	108	constructor.setAccessible(true);
115	109	try {
116	110	fInstance= constructor.newInstance(constructorArgs);
117		} catch (IllegalArgumentException e) {
118		fail(e);
119		} catch (InvocationTargetException e) {
120		fail(e);
121		} catch (InstantiationException e) {
122		fail(e);
123		} catch (IllegalAccessException e) {
	111	} catch (IllegalArgumentException \| InvocationTargetException \| InstantiationException \| IllegalAccessException e) {
124	112	fail(e);
125	113	}
126	114	}

137	125	public Accessor(String className, ClassLoader classLoader) {
138	126	try {
139	127	fClass= Class.forName(className, true, classLoader);
140		} catch (ClassNotFoundException e) {
141		fail(e);
142		} catch (ExceptionInInitializerError e) {
	128	} catch (ClassNotFoundException \| ExceptionInInitializerError e) {
143	129	fail(e);
144	130	}
145	131	}

172	158	Method method= null;
173	159	try {
174	160	method= fClass.getDeclaredMethod(methodName, types);
175		} catch (SecurityException e) {
176		fail(e);
177		} catch (NoSuchMethodException e) {
	161	} catch (SecurityException \| NoSuchMethodException e) {
178	162	fail(e);
179	163	}
180	164	Assert.isNotNull(method);
181	165	method.setAccessible(true);
182	166	try {
183	167	return method.invoke(fInstance, arguments);
184		} catch (IllegalArgumentException e) {
185		fail(e);
186		} catch (InvocationTargetException e) {
187		fail(e);
188		} catch (IllegalAccessException e) {
	168	} catch (IllegalArgumentException \| InvocationTargetException \| IllegalAccessException e) {
189	169	fail(e);
190	170	}
191	171	return null;

201	181	Field field= getField(fieldName);
202	182	try {
203	183	field.set(fInstance, value);
204		} catch (IllegalArgumentException e) {
205		fail(e);
206		} catch (IllegalAccessException e) {
	184	} catch (IllegalArgumentException \| IllegalAccessException e) {
207	185	fail(e);
208	186	}
209	187	}

218	196	Field field= getField(fieldName);
219	197	try {
220	198	field.setBoolean(fInstance, value);
221		} catch (IllegalArgumentException e) {
222		fail(e);
223		} catch (IllegalAccessException e) {
	199	} catch (IllegalArgumentException \| IllegalAccessException e) {
224	200	fail(e);
225	201	}
226	202	}

235	211	Field field= getField(fieldName);
236	212	try {
237	213	field.setInt(fInstance, value);
238		} catch (IllegalArgumentException e) {
239		fail(e);
240		} catch (IllegalAccessException e) {
	214	} catch (IllegalArgumentException \| IllegalAccessException e) {
241	215	fail(e);
242	216	}
243	217	}

252	226	Field field= getField(fieldName);
253	227	try {
254	228	return field.get(fInstance);
255		} catch (IllegalArgumentException e) {
256		fail(e);
257		} catch (IllegalAccessException e) {
	229	} catch (IllegalArgumentException \| IllegalAccessException e) {
258	230	fail(e);
259	231	}
260	232	// Unreachable code

271	243	Field field= getField(fieldName);
272	244	try {
273	245	return field.getBoolean(fInstance);
274		} catch (IllegalArgumentException e) {
275		fail(e);
276		} catch (IllegalAccessException e) {
	246	} catch (IllegalArgumentException \| IllegalAccessException e) {
277	247	fail(e);
278	248	}
279	249	// Unreachable code

290	260	Field field= getField(fieldName);
291	261	try {
292	262	return field.getInt(fInstance);
293		} catch (IllegalArgumentException e) {
294		fail(e);
295		} catch (IllegalAccessException e) {
	263	} catch (IllegalArgumentException \| IllegalAccessException e) {
296	264	fail(e);
297	265	}
298	266	// Unreachable code

303	271	Field field= null;
304	272	try {
305	273	field= fClass.getDeclaredField(fieldName);
306		} catch (SecurityException e) {
307		fail(e);
308		} catch (NoSuchFieldException e) {
	274	} catch (SecurityException \| NoSuchFieldException e) {
309	275	fail(e);
310	276	}
311	277	field.setAccessible(true);

+25

-1

org.eclipse.text.tests/src/org/eclipse/text/tests/FindReplaceDocumentAdapterTest.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2013 IBM Corporation and others.
	1	* Copyright (c) 2000, 2017 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

8	8	* IBM Corporation - initial API and implementation
9	9	* Cagatay Calli <ccalli@gmail.com> - [find/replace] retain caps when replacing - https://bugs.eclipse.org/bugs/show_bug.cgi?id=28949
10	10	* Cagatay Calli <ccalli@gmail.com> - [find/replace] define & fix behavior of retain caps with other escapes and text before \C - https://bugs.eclipse.org/bugs/show_bug.cgi?id=217061
	11	* Florian Ingerl <imelflorianingerl@gmail.com> - [find/replace] replace doesn't work when using a regex with a lookahead or boundary matchers - https://bugs.eclipse.org/bugs/show_bug.cgi?id=109481
11	12	*******************************************************************************/
12	13	package org.eclipse.text.tests;
13	14

499	500	}
500	501	fail();
501	502	}
	503
	504	@Test
	505	public void testRegexReplaceWithLookarounds() throws Exception {
	506	fDocument.set("1<2<3<4");
	507	replaceAllRegex("(?<=(\\d))\\<(\\d)(?=\\<(\\d))", "<($1+$3)/2=$2", true);
	508	assertEquals("1<(1+3)/2=2<(2+4)/2=3<4", fDocument.get());
	509
	510	fDocument.set("1<2<3<4");
	511	replaceAllRegex("(?<=(\\d)\\<)(\\d)\\<(?=(\\d))", "$2=($1+$3)/2<", false);
	512	assertEquals("1<2=(1+3)/2<3=(2+4)/2<4", fDocument.get());
	513	}
	514
	515	private void replaceAllRegex(String findString, String replaceString, boolean forwardSearch) throws BadLocationException {
	516	FindReplaceDocumentAdapter findReplaceDocumentAdapter= new FindReplaceDocumentAdapter(fDocument);
	517
	518	int index= forwardSearch ? 0 : fDocument.getLength();
	519	while(index!=-1) {
	520	if(findReplaceDocumentAdapter.find(index, findString, forwardSearch, true, false, true)==null)
	521	break;
	522	IRegion region= findReplaceDocumentAdapter.replace(replaceString, true);
	523	index= forwardSearch ? region.getOffset() + region.getLength() : region.getOffset() - 1;
	524	}
	525	}
502	526	}

+53

-51

org.eclipse.text.tests/src/org/eclipse/text/tests/TextStoreTest.java less more

62	62	fTextStore= null;
63	63	fTracker= null;
64	64	}
65
	65
66	66	@Test
67	67	public void testGet1() throws Exception {
68	68	set("xxxxx");

76	76	}
77	77
78	78	}
79
	79
80	80	@Test
81	81	public void testGet2() throws Exception {
82	82	set("xxxxx");

90	90	}
91	91
92	92	}
93
	93
94	94	@Test
95	95	public void testEditScript1() throws Exception {
96	96	replace(0, fTextStore.getLength(), "x");

120	120	} catch (IndexOutOfBoundsException e) {
121	121	}
122	122	}
123
	123
124	124	@Test
125	125	public void testEmptyLines() throws Exception {
126	126

130	130	replace(0, 0, "\n\n\n\n\n");
131	131	assertTextStoreContents("\n\n\n\n\n");
132	132	}
133
	133
134	134	@Test
135	135	public void testInsert1() throws Exception {
136	136

149	149	replace(11, 5, "y\nxyz");
150	150	assertTextStoreContents("x\nxyyyy\nxy\ny\nxyz\nx\n");
151	151	}
152
	152
153	153	@Test
154	154	public void testInsert2() throws Exception {
155	155	replace(3, 0, "yyyy");

158	158	replace(9, 0, "y\ny\ny");
159	159	assertTextStoreContents("x\nxyyyy\nxy\ny\ny\nx\nx\n");
160	160	}
161
	161
162	162	@Test
163	163	public void testLinesNumbers() throws Exception {
164	164	replace(0, 10, "\na\nbb\nccc\ndddd\neeeee\n");

173	173	offset+= (i + 1);
174	174	}
175	175	}
176
	176
177	177	@Test
178	178	public void testOffsets() throws Exception {
179	179	for (int i= 0; i < 5; i++) {

195	195	assertTrue("invalid line number " + line + " for position " + i + " should be " + l, l == line);
196	196	}
197	197	}
198
	198
199	199	@Test
200	200	public void testRemove() throws Exception {
201	201	replace(3, 1, null);

210	210	replace(0, 3, null);
211	211	assertTextStoreContents("");
212	212	}
213
	213
214	214	@Test
215	215	public void testReplace() throws Exception {
216	216	replace(0, fTextStore.getLength(), "\tx\n\tx\n\tx\n\tx\n\tx\n");
217	217	assertTextStoreContents("\tx\n\tx\n\tx\n\tx\n\tx\n");
218	218	}
219
	219
220	220	@Test
221	221	public void testReplace2() throws Exception {
222	222	replace(0, fTextStore.getLength(), "x");

225	225	replace(0, fTextStore.getLength(), "x\nx\nx\n");
226	226	assertTextStoreContents("x\nx\nx\n");
227	227	}
228
	228
229	229	@Test
230	230	public void testReplace3() throws Exception {
231	231	replace(1, 1, "\n");
232	232	assertTextStoreContents("x\nx\nx\nx\nx\n");
233	233	}
234
	234
235	235	@Test
236	236	public void testReplace4() throws Exception {
237	237	int lines= fTracker.getNumberOfLines();

244	244	previous= fTracker.getLineInformation(i);
245	245	}
246	246	}
247
	247
248	248	@Test
249	249	public void testShiftLeft() throws Exception {
250	250	replace(0, fTextStore.getLength(), "\tx\n\tx\n\tx\n\tx\n\tx\n");

257	257
258	258	assertTextStoreContents("x\nx\nx\nx\nx\n");
259	259	}
260
	260
261	261	@Test
262	262	public void testShiftRight() throws Exception {
263	263	for (int i= 0; i < 5; i++) {

267	267
268	268	assertTextStoreContents("\tx\n\tx\n\tx\n\tx\n\tx\n");
269	269	}
270
	270
271	271	@Test
272	272	public void testDeleteEmptyLine() throws Exception {
273	273	set("x\nx\n\nx\n\n");

290	290	}
291	291
292	292	}
293
	293
294	294	@Test
295	295	public void testDeleteLines() throws Exception {
296		String content= "";
	296	StringBuilder content= new StringBuilder();
297	297	for (int i= 0; i < 50; i++) {
298		content += "x\nx\n\nx\n\n";
299		set(content);
300
301		String expected= content;
	298	content.append("x\nx\n\nx\n\n");
	299	set(content.toString());
	300
	301	String expected= content.toString();
302	302	int lines= fTracker.getNumberOfLines();
303	303	for (int line= 0; line < lines; line++) {
304	304	int offset= fTracker.getLineOffset(0);

308	308	assertTextStoreContents(expected);
309	309	}
310	310	}
311		content= "";
	311	content = new StringBuilder();
312	312	for (int i= 0; i < 50; i++) {
313		content += "x\nx\n\nx\n\n";
314		set(content);
315
316		String expected= content;
	313	content.append("x\nx\n\nx\n\n");
	314	set(content.toString());
	315
	316	String expected= content.toString();
317	317	int lines= fTracker.getNumberOfLines();
318	318	for (int line= lines - 1; line >= 0; line--) {
319	319	int offset= fTracker.getLineOffset(line);

324	324	}
325	325	}
326	326	}
327
	327
328	328	@Test
329	329	public void testDeleteLines2() throws Exception {
330		String content= "";
	330	StringBuilder content= new StringBuilder();
331	331	for (int i= 0; i < 50; i++) {
332		content += "xxxxxxxxxxxxxx";
333		set(content);
334
335		String expected= content;
	332	content.append("xxxxxxxxxxxxxx");
	333	set(content.toString());
	334
	335	String expected= content.toString();
336	336	int lines= fTracker.getNumberOfLines();
337	337	for (int line= 0; line < lines; line++) {
338	338	int offset= fTracker.getLineOffset(0);

342	342	assertTextStoreContents(expected);
343	343	}
344	344	}
345		content= "";
	345	content= new StringBuilder();
346	346	for (int i= 0; i < 50; i++) {
347		content += "xxxxxxxxxxxxxx";
348		set(content);
349
350		String expected= content;
	347	content.append("xxxxxxxxxxxxxx");
	348	set(content.toString());
	349
	350	String expected= content.toString();
351	351	int lines= fTracker.getNumberOfLines();
352	352	for (int line= lines - 1; line >= 0; line--) {
353	353	int offset= fTracker.getLineOffset(line);

358	358	}
359	359	}
360	360	}
361
	361
362	362	@Test
363	363	public void testSet() throws Exception {
364		String content= "";
	364	StringBuilder content = new StringBuilder();
365	365	for (int i= 0; i < 35; i++) {
366	366	int[] lenghts= new int[i + 1];
367		for (int j= 0; j < i + 1; j++)
	367	for (int j= 0; j < i + 1; j++) {
368	368	lenghts[j]= j;
369		for (int j= 0; j < i; j++)
370		content+= "x";
371
372		set(content);
373		assertTextStoreContents(content);
374
375		content+= "\n";
376		}
377		}
378
	369	}
	370	for (int j= 0; j < i; j++) {
	371	content.append("x");
	372	}
	373
	374	set(content.toString());
	375	assertTextStoreContents(content.toString());
	376
	377	content.append('\n');
	378	}
	379	}
	380
379	381	@Test
380	382	public void testFunnyLastLineCompatibility() throws Exception {
381	383	/* empty last line */

+9

-2

org.eclipse.ui.editors/.settings/.api_filters less more

0	0	<?xml version="1.0" encoding="UTF-8" standalone="no"?>
1	1	<component id="org.eclipse.ui.editors" version="2">
2	2	<resource path="META-INF/MANIFEST.MF">
3		<filter comment="API was backported to 4.6.2" id="926941240">
	3	<filter comment="The new field has @noreference, hence not a new API" id="924844039">
4	4	<message_arguments>
	5	<message_argument value="3.11.100"/>
5	6	<message_argument value="3.11.0"/>
6		<message_argument value="3.10.1"/>
7	7	</message_arguments>
8	8	</filter>
9	9	</resource>

12	12	<message_arguments>
13	13	<message_argument value="IAbstractTextEditorHelpContextIds"/>
14	14	<message_argument value="ITextEditorHelpContextIds"/>
	15	</message_arguments>
	16	</filter>
	17	</resource>
	18	<resource path="src/org/eclipse/ui/texteditor/AbstractDecoratedTextEditorPreferenceConstants.java" type="org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants">
	19	<filter comment="@since tag not needed since @noreference and hence no API" id="1143996420">
	20	<message_arguments>
	21	<message_argument value="EDITOR_PRINT_MARGIN_ALLOW_OVERRIDE"/>
15	22	</message_arguments>
16	23	</filter>
17	24	</resource>

+58

-0

org.eclipse.ui.editors/.settings/org.eclipse.jdt.ui.prefs less more

0	0	eclipse.preferences.version=1
	1	editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
1	2	formatter_profile=_JDT UI Code Style Conventions
2	3	formatter_settings_version=12
3	4	org.eclipse.jdt.ui.exception.name=e

8	9	org.eclipse.jdt.ui.ondemandthreshold=99
9	10	org.eclipse.jdt.ui.overrideannotation=true
10	11	org.eclipse.jdt.ui.staticondemandthreshold=99
	12	sp_cleanup.add_default_serial_version_id=true
	13	sp_cleanup.add_generated_serial_version_id=false
	14	sp_cleanup.add_missing_annotations=true
	15	sp_cleanup.add_missing_deprecated_annotations=true
	16	sp_cleanup.add_missing_methods=false
	17	sp_cleanup.add_missing_nls_tags=false
	18	sp_cleanup.add_missing_override_annotations=true
	19	sp_cleanup.add_missing_override_annotations_interface_methods=true
	20	sp_cleanup.add_serial_version_id=false
	21	sp_cleanup.always_use_blocks=true
	22	sp_cleanup.always_use_parentheses_in_expressions=false
	23	sp_cleanup.always_use_this_for_non_static_field_access=false
	24	sp_cleanup.always_use_this_for_non_static_method_access=false
	25	sp_cleanup.convert_functional_interfaces=false
	26	sp_cleanup.convert_to_enhanced_for_loop=false
	27	sp_cleanup.correct_indentation=false
	28	sp_cleanup.format_source_code=true
	29	sp_cleanup.format_source_code_changes_only=true
	30	sp_cleanup.insert_inferred_type_arguments=false
	31	sp_cleanup.make_local_variable_final=true
	32	sp_cleanup.make_parameters_final=false
	33	sp_cleanup.make_private_fields_final=true
	34	sp_cleanup.make_type_abstract_if_missing_method=false
	35	sp_cleanup.make_variable_declarations_final=false
	36	sp_cleanup.never_use_blocks=false
	37	sp_cleanup.never_use_parentheses_in_expressions=true
	38	sp_cleanup.on_save_use_additional_actions=true
	39	sp_cleanup.organize_imports=true
	40	sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
	41	sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
	42	sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
	43	sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
	44	sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
	45	sp_cleanup.remove_private_constructors=true
	46	sp_cleanup.remove_redundant_type_arguments=false
	47	sp_cleanup.remove_trailing_whitespaces=false
	48	sp_cleanup.remove_trailing_whitespaces_all=true
	49	sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
	50	sp_cleanup.remove_unnecessary_casts=true
	51	sp_cleanup.remove_unnecessary_nls_tags=false
	52	sp_cleanup.remove_unused_imports=false
	53	sp_cleanup.remove_unused_local_variables=false
	54	sp_cleanup.remove_unused_private_fields=true
	55	sp_cleanup.remove_unused_private_members=false
	56	sp_cleanup.remove_unused_private_methods=true
	57	sp_cleanup.remove_unused_private_types=true
	58	sp_cleanup.sort_members=false
	59	sp_cleanup.sort_members_all=false
	60	sp_cleanup.use_anonymous_class_creation=false
	61	sp_cleanup.use_blocks=false
	62	sp_cleanup.use_blocks_only_for_return_and_throw=false
	63	sp_cleanup.use_lambda=true
	64	sp_cleanup.use_parentheses_in_expressions=false
	65	sp_cleanup.use_this_for_non_static_field_access=false
	66	sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true
	67	sp_cleanup.use_this_for_non_static_method_access=false
	68	sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true

+2

-1

org.eclipse.ui.editors/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %pluginName
3	3	Bundle-SymbolicName: org.eclipse.ui.editors; singleton:=true
4		Bundle-Version: 3.11.0.qualifier
	4	Bundle-Version: 3.11.100.qualifier
5	5	Bundle-Activator: org.eclipse.ui.internal.editors.text.EditorsPlugin
6	6	Bundle-ActivationPolicy: lazy
7	7	Bundle-Vendor: %providerName

26	26	org.eclipse.core.filesystem;bundle-version="[1.2.0,2.0.0)"
27	27	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
28	28	Import-Package: com.ibm.icu.text
	29	Automatic-Module-Name: org.eclipse.ui.editors

+1

-0

org.eclipse.ui.editors/forceQualifierUpdate.txt less more

0	0	# To force a version qualifier update add the bug here
1	1	Bug 509931: Comparator errors in M20170104-0545
	2	Bug 534597 - Unanticipated comparator errors in I20180511-2000⏎

org.eclipse.ui.editors/icons/full/dtool16/next_nav.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/dtool16/next_nav@2x.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/dtool16/prev_nav.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/dtool16/prev_nav@2x.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/etool16/next_nav.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/etool16/next_nav@2x.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/etool16/prev_nav.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/etool16/prev_nav@2x.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/obj16/quick_fix_info_obj.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/obj16/quick_fix_info_obj@2x.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/obj16/quick_fix_warning_obj.png less more

Binary diff not shown

org.eclipse.ui.editors/icons/full/obj16/quick_fix_warning_obj@2x.png less more

Binary diff not shown

+0

-15

~~org.eclipse.ui.editors/migration_guidelines.html~~ less more

0		<!DOCTYPE doctype PUBLIC "-//w3c//dtd html 4.0 transitional//en">
1		<html><head>
2		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
3		<meta name="Author" content="IBM"><title>Platform Text Migration Guide</title>
4		<link rel="stylesheet" href="http://dev.eclipse.org/default_style.css" type="text/css">
5		</head>
6		<h1>Platform Text Migration Guide</h1>
7		<p>
8		Incompatible and interesting new APIs can be found in the documentation in two ways:
9		</p>
10		<ul>
11		<li>Help > Help Contents > Platform Plug-in Developer Guide > 3.4 Plug-in Migration Guide</li>
12		<li>load the <code>org.eclipse.platform.doc.isv</code> plug-in from CVS and open <code>porting/eclipse_3_4_porting_guide.html</code></li>
13		</ul>
14		</body></html>⏎

+0

-34

~~org.eclipse.ui.editors/migration_guidelines_3.1.html~~ less more

0		<!DOCTYPE doctype PUBLIC "-//w3c//dtd html 4.0 transitional//en">
1		<html><head>
2		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
3		<meta name="Author" content="IBM"><title>Platform Text Migration Guide</title>
4		<link rel="stylesheet" href="http://dev.eclipse.org/default_style.css" type="text/css">
5		</head>
6		<body bgcolor="#ffffff" text="#000000">
7		<body text="#000000" bgcolor="#ffffff">
8		<p>
9		This document lists the API changes that occurred between R3.0 and R3.1 and
10		how to migrate from the R3.0 API to the R3.1 API.
11		</p>
12		<p></p>
13		<table style="width: 1000px; height: 437px;" border="0" cellpadding="2" cellspacing="5">
14		<tbody>
15		<tr>
16		<td align="left" width="72%"> <font size="+3"><b>Platform Text -
17		</b></font><font size="+3"><b>Binary Compatibility Breakage from R3.0 to R3.1</b></font><font size="+3"><b></b></font><font color="#8080ff" size="-2"><br>
18		</font></td>
19		</tr>
20		<tr>
21		<td>
22		<ul>
23		<li><span style="font-weight: bold; font-style: italic;">org.eclipse.jface.text.DefaultPositionUpdater.update(DocumentEvent event)</span>: to prevent holding on to the cached document after calling this method we set <code>fDocument</code> to <code>null</code> at the end of this method. Subclasses that extend <code>update(DocumentEvent event)</code> i.e. call <code>super.update(event)</code> will be broken if they access <code>fDocument</code> after that call. To fix this either replace <code>fDocument</code> with <code>event.getDocument()</code> or set <code>fDocument</code> again. If you do the latter do not forget to set it back to <code>null</code> at the end of your method.<br>
24		</li></ul>
25		</td>
26		</tr>
27		<tr>
28		<td align="left" width="72%"> <font size="+3"><b>Platform Text - </b></font><font size="+3"><b>Breaking API changes from R3.0 to R3.1</b></font><font color="#8080ff" size="-2">
29		</font></td></tr>
30		</tbody>
31		</table>
32		<p> </p>
33		</body></html>⏎

+0

-33

~~org.eclipse.ui.editors/migration_guidelines_3.2.html~~ less more

0		<!DOCTYPE doctype PUBLIC "-//w3c//dtd html 4.0 transitional//en">
1		<html><head>
2		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
3		<meta name="Author" content="IBM"><title>Platform Text Migration Guide</title>
4		<link rel="stylesheet" href="http://dev.eclipse.org/default_style.css" type="text/css">
5		</head>
6		<body bgcolor="#ffffff" text="#000000">
7		<body text="#000000" bgcolor="#ffffff">
8		<p>
9		This document lists the API changes that occurred between R3.1 and R3.2 and
10		how to migrate from the R3.1 API to the R3.2 API.
11		</p>
12		<p></p>
13		<table style="width: 1000px; height: 437px;" border="0" cellpadding="2" cellspacing="5">
14		<tbody>
15		<tr>
16		<td align="left" width="72%"> <font size="+3"><b>Platform Text -
17		</b></font><font size="+3"><b>Binary Compatibility Breakage from R3.1 to R3.2</b></font><font size="+3"><b></b></font><font color="#8080ff" size="-2"><br>
18		</font></td>
19		</tr>
20		<tr>
21		<td>
22		<ul>
23		</ul>
24		</td>
25		</tr>
26		<tr>
27		<td align="left" width="72%"> <font size="+3"><b>Platform Text - </b></font><font size="+3"><b>Breaking API changes from R3.1 to R3.2</b></font><font color="#8080ff" size="-2">
28		</font></td></tr>
29		</tbody>
30		</table>
31		<p> </p>
32		</body></html>⏎

+0

-57

~~org.eclipse.ui.editors/migration_guidelines_3_0.html~~ less more

0		<!DOCTYPE doctype PUBLIC "-//w3c//dtd html 4.0 transitional//en"><html><head>
1		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
2		<meta name="Author" content="IBM"><title>Platform Text Breaking API changes</title></head><body text="#000000" bgcolor="#ffffff">
3
4		<table border="0" cellspacing="5" cellpadding="2" width="100%">
5		<tbody>
6		<tr>
7		<td align="left" width="72%"> <font size="+3"><b>Platform Text -
8		Breaking API changes from R2.1 to R3.0</b></font> <font size="-2" color="#8080ff"><br>
9		</font></td>
10		</tr>
11		<tr>
12		<td>
13		<ul>
14		<li><span style="font-weight: bold; font-style: italic;">org.eclipse.jface.text.source.AnnotationModel.addAnnotation(Annotation, Position, boolean)</span>:
15		changed signature to throw <code>org.eclipse.jface.text.BadLocationException</code>
16		in order to add support for better handling of invalid document
17		positions. Only clients which extend (i.e. call super) this method will be
18		broken. To fix the problem either catch the exception from the super
19		call or change the signature in the extended method. The latter is
20		suggested since clients should decide how to handle invalid document
21		positions.<br>
22		</li>
23		<li><span style="font-weight: bold; font-style: italic;">org.eclipse.ui.texteditor.TextEditorAction.canModifyEditor()</span>:
24		added predicate method that checks whether the action's editor can be modified. The method calls different methods on the underlying editor depending on
25		which interfaces the editor implements. The method will call <code>ITextEditorExtension2.isEditorInputModifiable()</code> if it is available. Modifing actions
26		can call the method when updating their enablement state.<br>
27		</li>
28		<li><span style="font-weight: bold; font-style: italic;">org.eclipse.ui.texteditor.TextEditorAction.validateEdit()</span>:
29		added predicate method that checks and updates the modifiable state of the action's editor. The method calls different methods on the underlying editor depending on
30		which interfaces the editor implements. The method will call <code>ITextEditorExtension2.validateEditorInputState()</code> if it is available. Modifing actions
31		can call the method before running modifing the editor's content.<br>
32		</li>
33		<li><span style="font-weight: bold; font-style: italic;">org.eclipse.ui.texteditor.AbstractDecoratedTextEditor</span>:
34		A new intermediate class layer has been added between <code>StatusTextEditor</code> and other editors, namely <code>TextEditor</code> and <code>JavaEditor</code>. The additional layer
35		includes features found commonly in advanced editors (and especially source editors) such as:
36		<ul>
37		<li>a vertical ruler to display annotations, line numbers, and quick diff information</li>
38		<li>an overview ruler</li>
39		<li>current line hightlighting,</li>
40		<li>and print margin display</li>
41		</ul>
42		Implementors of an editor may choose to extend <code>AbstractDecoratedTextEditor</code> instead of <code>TextEditor</code>.
43		<br>
44		</li>
45		</ul>
46		</td>
47		</tr>
48		<tr>
49		<td> <font size="-1"> This document lists the breaking API
50		changes that occurred between R2.1 and R3.0 and how to migrate from the
51		R2.1 API to the R3.0 API. </font> </td>
52		</tr>
53		</tbody>
54		</table>
55		<p> </p>
56		</body></html>⏎

+2

-2

org.eclipse.ui.editors/plugin.properties less more

29	29	removeTrailingWhitespace.description= Removes the trailing whitespace of each line
30	30
31	31	NewUntitledTextFile.label= Untitled Text File
32		NewUntitledTextFile.description= Creates an empty untitled text file
	32	NewUntitledTextFile.description= Create an empty untitled text file
33	33
34	34	ActionDefinition.quickDiff.name= Quick Diff Toggle
35	35	ActionDefinition.quickDiff.description= Toggles quick diff information display on the line number ruler

112	112	conversionActionSet.label= Convert Line Delimiters
113	113	conversionSubMenu.label= Con&vert Line Delimiters To
114	114
115		preferenceKeywords.general= text editor tabs spaces undo history ruler overview hyperlink overwrite colors range indicator typing appearance derived navigation smart caret positioning invisible whitespace characters drag drop dnd hovers sticky enrich rich
	115	preferenceKeywords.general= pop-up text editor tabs spaces undo history ruler overview hyperlink overwrite colors range indicator typing appearance derived navigation smart caret positioning invisible whitespace characters drag drop dnd hovers popup sticky enrich rich
116	116	preferenceKeywords.tabWidth= tab width
117	117	preferenceKeywords.lineNumber= line numbers
118	118	preferenceKeywords.printMargin= print margin

+2

-2

org.eclipse.ui.editors/pom.xml less more

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<groupId>org.eclipse.ui</groupId>
19	19	<artifactId>org.eclipse.ui.editors</artifactId>
20		<version>3.11.0-SNAPSHOT</version>
	20	<version>3.11.100-SNAPSHOT</version>
21	21	<packaging>eclipse-plugin</packaging>
22	22	</project>

+4

-22

org.eclipse.ui.editors/src/org/eclipse/ui/editors/text/FileDocumentProvider.java less more

376	376	protected boolean setDocumentContent(IDocument document, IEditorInput editorInput) throws CoreException {
377	377	if (editorInput instanceof IFileEditorInput) {
378	378	IFile file= ((IFileEditorInput) editorInput).getFile();
379		InputStream stream= file.getContents(false);
380		try {
	379	try (InputStream stream= file.getContents(false)) {
381	380	setDocumentContent(document, stream);
382		} finally {
383		try {
384		stream.close();
385		} catch (IOException x) {
386		}
	381	} catch (IOException x) {
387	382	}
388	383	return true;
389	384	}

394	389	protected boolean setDocumentContent(IDocument document, IEditorInput editorInput, String encoding) throws CoreException {
395	390	if (editorInput instanceof IFileEditorInput) {
396	391	IFile file= ((IFileEditorInput) editorInput).getFile();
397		InputStream contentStream= file.getContents(false);
398		try {
399
	392	try (InputStream contentStream= file.getContents(false)) {
400	393	FileInfo info= (FileInfo)getElementInfo(editorInput);
401	394	boolean removeBOM= false;
402	395	if (CHARSET_UTF_8.equals(encoding)) {

427	420	String message= (ex.getMessage() != null ? ex.getMessage() : ""); //$NON-NLS-1$
428	421	IStatus s= new Status(IStatus.ERROR, PlatformUI.PLUGIN_ID, IStatus.OK, message, ex);
429	422	throw new CoreException(s);
430		} finally {
431		try {
432		contentStream.close();
433		} catch (IOException e1) {
434		}
435	423	}
436	424	return true;
437	425	}

665	653	return encoding;
666	654
667	655	// Probe content
668		Reader reader= new DocumentReader(document);
669		try {
	656	try (Reader reader= new DocumentReader(document)) {
670	657	QualifiedName[] options= new QualifiedName[] { IContentDescription.CHARSET, IContentDescription.BYTE_ORDER_MARK };
671	658	IContentDescription description= Platform.getContentTypeManager().getDescriptionFor(reader, targetFile.getName(), options);
672	659	if (description != null) {

676	663	}
677	664	} catch (IOException ex) {
678	665	// continue with next strategy
679		} finally {
680		try {
681		reader.close();
682		} catch (IOException x) {
683		}
684	666	}
685	667
686	668	// Use file's encoding if the file has a BOM

+9

-23

org.eclipse.ui.editors/src/org/eclipse/ui/editors/text/StorageDocumentProvider.java less more

137	137	encoding= getDefaultEncoding();
138	138
139	139	in= new BufferedReader(new InputStreamReader(contentStream, encoding), DEFAULT_FILE_SIZE);
140		StringBuffer buffer= new StringBuffer(DEFAULT_FILE_SIZE);
	140	StringBuilder buffer= new StringBuilder(DEFAULT_FILE_SIZE);
141	141	char[] readBuffer= new char[2048];
142	142	int n= in.read(readBuffer);
143	143	while (n > 0) {

190	190	protected boolean setDocumentContent(IDocument document, IEditorInput editorInput, String encoding) throws CoreException {
191	191	if (editorInput instanceof IStorageEditorInput) {
192	192	IStorage storage= ((IStorageEditorInput) editorInput).getStorage();
193		InputStream stream= storage.getContents();
194		try {
	193	try (InputStream stream= storage.getContents()) {
195	194	setDocumentContent(document, stream, encoding);
196		} finally {
197		try {
198		stream.close();
199		} catch (IOException x) {
200		}
	195	} catch (IOException x) {
201	196	}
202	197	return true;
203	198	}

408	403	public IContentType getContentType(Object element) throws CoreException {
409	404	if (element instanceof IStorageEditorInput) {
410	405	IStorage storage= ((IStorageEditorInput) element).getStorage();
411		Reader reader= null;
412		InputStream stream= null;
413	406	try {
414	407	IContentDescription desc;
415	408	IDocument document= getDocument(element);
416	409	if (document != null) {
417		reader= new DocumentReader(document);
418		desc= Platform.getContentTypeManager().getDescriptionFor(reader, storage.getName(), NO_PROPERTIES);
	410	try (Reader reader= new DocumentReader(document)) {
	411	desc= Platform.getContentTypeManager().getDescriptionFor(reader, storage.getName(), NO_PROPERTIES);
	412	}
419	413	} else {
420		stream= storage.getContents();
421		desc= Platform.getContentTypeManager().getDescriptionFor(stream, storage.getName(), NO_PROPERTIES);
	414	try (InputStream stream= storage.getContents()) {
	415	desc= Platform.getContentTypeManager().getDescriptionFor(stream, storage.getName(), NO_PROPERTIES);
	416	}
422	417	}
423	418	if (desc != null && desc.getContentType() != null)
424	419	return desc.getContentType();

435	430	else
436	431	message= TextEditorMessages.StorageDocumentProvider_getContentDescription;
437	432	throw new CoreException(new Status(IStatus.ERROR, EditorsUI.PLUGIN_ID, IStatus.OK, message, x));
438		} finally {
439		try {
440		// Note: either 'reader' or 'stream' is null
441		if (reader != null)
442		reader.close();
443		if (stream != null)
444		stream.close();
445		} catch (IOException x) {
446		}
447	433	}
448	434	}
449	435	return super.getContentType(element);

+8

-22

org.eclipse.ui.editors/src/org/eclipse/ui/editors/text/templates/ContributionTemplateStore.java less more

131	131	URL url= FileLocator.find(plugin, Path.fromOSString(file), null);
132	132	if (url != null) {
133	133	ResourceBundle bundle= null;
134		InputStream bundleStream= null;
135		InputStream stream= null;
136		try {
137		String translations= element.getAttribute(TRANSLATIONS);
138		if (translations != null) {
139		URL bundleURL= FileLocator.find(plugin, Path.fromOSString(translations), null);
140		if (bundleURL != null) {
141		bundleStream= bundleURL.openStream();
	134	String translations= element.getAttribute(TRANSLATIONS);
	135	if (translations != null) {
	136	URL bundleURL= FileLocator.find(plugin, Path.fromOSString(translations), null);
	137	if (bundleURL != null) {
	138	try (InputStream bundleStream= bundleURL.openStream()) {
142	139	bundle= new PropertyResourceBundle(bundleStream);
143	140	}
144	141	}
145
146		stream= new BufferedInputStream(url.openStream());
	142	}
	143
	144	try (InputStream stream= new BufferedInputStream(url.openStream())) {
147	145	TemplateReaderWriter reader= new TemplateReaderWriter();
148	146	TemplatePersistenceData[] datas= reader.read(stream, bundle);
149	147	for (int i= 0; i < datas.length; i++) {

157	155	templates.add(data);
158	156	}
159	157	}
160		} finally {
161		try {
162		if (bundleStream != null)
163		bundleStream.close();
164		} catch (IOException x) {
165		} finally {
166		try {
167		if (stream != null)
168		stream.close();
169		} catch (IOException x) {
170		}
171		}
172	158	}
173	159	}
174	160	}

+1

-1

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/quickdiff/LastSaveReferenceProvider.java less more

370	370	in= new BufferedReader(new InputStreamReader(contentStream), DEFAULT_FILE_SIZE);
371	371	else
372	372	in= new BufferedReader(new InputStreamReader(contentStream, encoding), DEFAULT_FILE_SIZE);
373		StringBuffer buffer= new StringBuffer(DEFAULT_FILE_SIZE);
	373	StringBuilder buffer= new StringBuilder(DEFAULT_FILE_SIZE);
374	374	char[] readBuffer= new char[2048];
375	375	int n= in.read(readBuffer);
376	376	while (n > 0) {

+4

-5

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/text/AnnotationsConfigurationBlock.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2015 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

43	43	import org.eclipse.jface.viewers.ComboViewer;
44	44	import org.eclipse.jface.viewers.ISelectionChangedListener;
45	45	import org.eclipse.jface.viewers.IStructuredContentProvider;
46		import org.eclipse.jface.viewers.IStructuredSelection;
47	46	import org.eclipse.jface.viewers.LabelProvider;
48	47	import org.eclipse.jface.viewers.SelectionChangedEvent;
49	48	import org.eclipse.jface.viewers.StructuredSelection;

316	315	final boolean value= fShowInTextCheckBox.getSelection();
317	316	if (value) {
318	317	// enable whatever is in the combo
319		String[] decoration= (String[]) ((IStructuredSelection) fDecorationViewer.getSelection()).getFirstElement();
	318	String[] decoration= (String[]) fDecorationViewer.getStructuredSelection().getFirstElement();
320	319	if (HIGHLIGHT.equals(decoration))
321	320	fStore.setValue(item.highlightKey, true);
322	321	else

394	393
395	394	@Override
396	395	public void selectionChanged(SelectionChangedEvent event) {
397		String[] decoration= (String[]) ((IStructuredSelection) fDecorationViewer.getSelection()).getFirstElement();
	396	String[] decoration= (String[]) fDecorationViewer.getStructuredSelection().getFirstElement();
398	397	ListItem item= getSelectedItem();
399	398
400	399	if (fShowInTextCheckBox.getSelection()) {

672	671	}
673	672
674	673	private ListItem getSelectedItem() {
675		return (ListItem) ((IStructuredSelection) fAnnotationTypeViewer.getSelection()).getFirstElement();
	674	return (ListItem) fAnnotationTypeViewer.getStructuredSelection().getFirstElement();
676	675	}
677	676
678	677	private void updateDecorationViewer(ListItem item, boolean changed) {

+1

-2

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/text/HyperlinkDetectorsConfigurationBlock.java less more

52	52	import org.eclipse.jface.viewers.ICheckStateListener;
53	53	import org.eclipse.jface.viewers.ILabelProviderListener;
54	54	import org.eclipse.jface.viewers.IStructuredContentProvider;
55		import org.eclipse.jface.viewers.IStructuredSelection;
56	55	import org.eclipse.jface.viewers.ITableLabelProvider;
57	56	import org.eclipse.jface.viewers.Viewer;
58	57

542	541	}
543	542
544	543	private ListItem getSelectedItem() {
545		return (ListItem)((IStructuredSelection) fHyperlinkDetectorsViewer.getSelection()).getFirstElement();
	544	return (ListItem) fHyperlinkDetectorsViewer.getStructuredSelection().getFirstElement();
546	545	}
547	546
548	547	private void handleHyperlinkKeyModifierModified() {

+4

-5

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/text/LinkedModeConfigurationBlock.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2015 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

43	43	import org.eclipse.jface.viewers.ComboViewer;
44	44	import org.eclipse.jface.viewers.ISelectionChangedListener;
45	45	import org.eclipse.jface.viewers.IStructuredContentProvider;
46		import org.eclipse.jface.viewers.IStructuredSelection;
47	46	import org.eclipse.jface.viewers.LabelProvider;
48	47	import org.eclipse.jface.viewers.SelectionChangedEvent;
49	48	import org.eclipse.jface.viewers.StructuredSelection;

314	313	final boolean value= fShowInTextCheckBox.getSelection();
315	314	if (value) {
316	315	// enable whatever is in the combo
317		String[] decoration= (String[]) ((IStructuredSelection) fDecorationViewer.getSelection()).getFirstElement();
	316	String[] decoration= (String[]) fDecorationViewer.getStructuredSelection().getFirstElement();
318	317	if (HIGHLIGHT.equals(decoration))
319	318	getPreferenceStore().setValue(item.highlightKey, true);
320	319	else

346	345
347	346	@Override
348	347	public void selectionChanged(SelectionChangedEvent event) {
349		String[] decoration= (String[]) ((IStructuredSelection) fDecorationViewer.getSelection()).getFirstElement();
	348	String[] decoration= (String[]) fDecorationViewer.getStructuredSelection().getFirstElement();
350	349	ListItem item= getSelectedItem();
351	350
352	351	if (fShowInTextCheckBox.getSelection()) {

456	455	}
457	456
458	457	private ListItem getSelectedItem() {
459		return (ListItem) ((IStructuredSelection) fAnnotationTypeViewer.getSelection()).getFirstElement();
	458	return (ListItem) fAnnotationTypeViewer.getStructuredSelection().getFirstElement();
460	459	}
461	460
462	461	private void updateDecorationViewer(ListItem item, boolean changed) {

+2

-2

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/text/SelectResourcesBlock.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2016 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

649	649	*/
650	650	@Override
651	651	public void selectionChanged(SelectionChangedEvent event) {
652		IStructuredSelection selection= (IStructuredSelection) event.getSelection();
	652	IStructuredSelection selection= event.getStructuredSelection();
653	653	Object selectedElement= selection.getFirstElement();
654	654	if (selectedElement == null) {
655	655	currentTreeSelection= null;

+2

-2

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/text/SelectResourcesDialog.java less more

348	348
349	349	private void updateSelectionCount() {
350	350	List<Object> listItems= fResourceGroup.getAllCheckedListItems();
351		int checkedFiles= listItems == null ? 0 : listItems.size();
352		StringBuffer buffer= new StringBuffer();
	351	int checkedFiles= listItems.size();
	352	StringBuilder buffer= new StringBuilder();
353	353	switch (checkedFiles) {
354	354	case 0:
355	355	buffer.append(TextEditorMessages.SelectResourcesDialog_noFilesSelected);

+2

-2

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/text/SpellingConfigurationBlock.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2009 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

347	347
348	348	@Override
349	349	public void selectionChanged(SelectionChangedEvent event) {
350		IStructuredSelection sel= (IStructuredSelection) event.getSelection();
	350	IStructuredSelection sel= event.getStructuredSelection();
351	351	if (sel.isEmpty())
352	352	return;
353	353	if (fCurrentBlock != null && fStatusMonitor.getStatus() != null && fStatusMonitor.getStatus().matches(IStatus.ERROR))

+7

-1

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/text/TextEditorDefaultsPreferencePage.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2016 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

702	702	overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_COLOR));
703	703	overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.INT, AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_COLUMN));
704	704	overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN));
	705	overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_ALLOW_OVERRIDE));
705	706
706	707	overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.INT, AbstractDecoratedTextEditorPreferenceConstants.EDITOR_UNDO_HISTORY_SIZE));
707	708

843	844	final IntegerDomain printMarginDomain= new IntegerDomain(20, 200);
844	845	final Control[] printMarginControls= addTextField(appearanceComposite, printMarginColumn, printMarginDomain, 15, 20);
845	846	createDependency(showPrintMarginButton, showPrintMargin, printMarginControls);
	847
	848	label= TextEditorMessages.TextEditorPreferencePage_printMarginAllowOverride;
	849	Preference printMarginAllowOverride= new Preference(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_ALLOW_OVERRIDE, label, null);
	850	final Button showPrintMarginAllowOverride= addCheckBox(appearanceComposite, printMarginAllowOverride, new BooleanDomain(), 0);
	851	createDependency(showPrintMarginButton, showPrintMargin, new Control[] { showPrintMarginAllowOverride });
846	852
847	853	showPrintMarginButton.addSelectionListener(new SelectionAdapter() {
848	854	@Override

+2

-1

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/text/TextEditorMessages.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2015 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

34	34	public static String TextEditorPreferencePage_convertTabsToSpaces;
35	35	public static String TextEditorPreferencePage_undoHistorySize;
36	36	public static String TextEditorPreferencePage_printMarginColumn;
	37	public static String TextEditorPreferencePage_printMarginAllowOverride;
37	38	public static String TextEditorPreferencePage_showLineNumbers;
38	39	public static String TextEditorPreferencePage_highlightCurrentLine;
39	40	public static String TextEditorPreferencePage_showPrintMargin;

+2

-1

org.eclipse.ui.editors/src/org/eclipse/ui/internal/editors/text/TextEditorMessages.properties less more

0	0	###############################################################################
1		# Copyright (c) 2000, 2015 IBM Corporation and others.
	1	# Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	# All rights reserved. This program and the accompanying materials
3	3	# are made available under the terms of the Eclipse Public License v1.0
4	4	# which accompanies this distribution, and is available at

16	16	TextEditorPreferencePage_convertTabsToSpaces=&Insert spaces for tabs
17	17	TextEditorPreferencePage_undoHistorySize=&Undo history size:
18	18	TextEditorPreferencePage_printMarginColumn=Print margin colu&mn:
	19	TextEditorPreferencePage_printMarginAllowOverride=Allow &editors to override the margin column
19	20	TextEditorPreferencePage_showLineNumbers=Show line num&bers
20	21	TextEditorPreferencePage_highlightCurrentLine=Hi&ghlight current line
21	22	TextEditorPreferencePage_showPrintMargin=Sho&w print margin

+9

-2

org.eclipse.ui.editors/src/org/eclipse/ui/texteditor/AbstractDecoratedTextEditor.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2016 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

201	201	*/
202	202	private final static String PRINT_MARGIN_COLUMN= AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_COLUMN;
203	203	/**
	204	* Preference key for telling whether editors are allowed to override the global print margin preferences.
	205	*/
	206	private final static String PRINT_MARGIN_ALLOW_OVERRIDE= AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_ALLOW_OVERRIDE;
	207	/**
204	208	* Preference key to get whether the overwrite mode is disabled.
205	209	* @since 3.1
206	210	*/

433	437
434	438	support.setCursorLinePainterPreferenceKeys(CURRENT_LINE, CURRENT_LINE_COLOR);
435	439	support.setMarginPainterPreferenceKeys(PRINT_MARGIN, PRINT_MARGIN_COLOR, PRINT_MARGIN_COLUMN);
436		support.setSymbolicFontName(getFontPropertyPreferenceKey());
437	440	}
438	441
439	442	/*

951	954	if (fSourceViewerDecorationSupport == null) {
952	955	fSourceViewerDecorationSupport= new SourceViewerDecorationSupport(viewer, getOverviewRuler(), getAnnotationAccess(), getSharedColors());
953	956	configureSourceViewerDecorationSupport(fSourceViewerDecorationSupport);
	957
	958	// Fix for overridden print margin column, see https://bugs.eclipse.org/468307
	959	if (!getPreferenceStore().getBoolean(PRINT_MARGIN_ALLOW_OVERRIDE))
	960	fSourceViewerDecorationSupport.setMarginPainterPreferenceKeys(PRINT_MARGIN, PRINT_MARGIN_COLOR, PRINT_MARGIN_COLUMN);
954	961	}
955	962	return fSourceViewerDecorationSupport;
956	963	}

+13

-1

org.eclipse.ui.editors/src/org/eclipse/ui/texteditor/AbstractDecoratedTextEditorPreferenceConstants.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2015 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

125	125	* </p>
126	126	*/
127	127	public final static String EDITOR_PRINT_MARGIN_COLUMN= "printMarginColumn"; //$NON-NLS-1$
	128
	129	/**
	130	* Tells whether editors are allowed to override the print margin preference (value
	131	* <code>"printMarginAllowOverride"</code>).
	132	* <p>
	133	* The preference value is of type <code>boolean</code>.
	134	* </p>
	135	*
	136	* @noreference This field is not intended to be referenced by clients.
	137	*/
	138	public final static String EDITOR_PRINT_MARGIN_ALLOW_OVERRIDE= "printMarginAllowOverride"; //$NON-NLS-1$
128	139
129	140	/**
130	141	* A named preference that controls whether the editor shows unknown

674	685
675	686	store.setDefault(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN, false);
676	687	store.setDefault(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_COLUMN, 80);
	688	store.setDefault(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_ALLOW_OVERRIDE, false);
677	689
678	690	store.setDefault(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_LINE_NUMBER_RULER, false);
679	691

+3

-3

org.eclipse.ui.editors/src/org/eclipse/ui/texteditor/ChainedPreferenceStore.java less more

433	433	if (thisValue instanceof Boolean)
434	434	return store.getBoolean(property) ? Boolean.TRUE : Boolean.FALSE;
435	435	else if (thisValue instanceof Double)
436		return new Double(store.getDouble(property));
	436	return Double.valueOf(store.getDouble(property));
437	437	else if (thisValue instanceof Float)
438		return new Float(store.getFloat(property));
	438	return Float.valueOf(store.getFloat(property));
439	439	else if (thisValue instanceof Integer)
440	440	return Integer.valueOf(store.getInt(property));
441	441	else if (thisValue instanceof Long)
442		return new Long(store.getLong(property));
	442	return Long.valueOf(store.getLong(property));
443	443	else if (thisValue instanceof String)
444	444	return store.getString(property);
445	445

+1

-0

org.eclipse.ui.editors/src/org/eclipse/ui/texteditor/ConstructedTextEditorMessages.properties less more

43	43	Editor.ManageBookmarks.remove.label=Remove Boo&kmark
44	44	Editor.ManageBookmarks.add.dialog.title=Add Bookmark
45	45	Editor.ManageBookmarks.add.dialog.message=Enter Bookmark name:
	46	Editor.ManageBookmarks.add.dialog.addbutton=&Add
46	47	Editor.ManageBookmarks.error.dialog.title=Managing Bookmarks
47	48	Editor.ManageBookmarks.error.dialog.message=Problems managing bookmarks
48	49

+22

-1

org.eclipse.ui.editors/src/org/eclipse/ui/texteditor/MarkerRulerAction.java less more

19	19
20	20	import org.osgi.framework.Bundle;
21	21
	22	import org.eclipse.swt.widgets.Button;
	23	import org.eclipse.swt.widgets.Composite;
22	24	import org.eclipse.swt.widgets.Shell;
23	25
24	26	import org.eclipse.core.commands.ExecutionException;

399	401	String proposal= (o instanceof String) ? (String) o : ""; //$NON-NLS-1$
400	402	String title= getString(fBundle, fPrefix + "add.dialog.title", fPrefix + "add.dialog.title"); //$NON-NLS-2$ //$NON-NLS-1$
401	403	String message= getString(fBundle, fPrefix + "add.dialog.message", fPrefix + "add.dialog.message"); //$NON-NLS-2$ //$NON-NLS-1$
	404	String addButtonText= getString(fBundle, fPrefix + "add.dialog.addbutton", fPrefix + "add.dialog.addbutton"); //$NON-NLS-1$ //$NON-NLS-2$
402	405	IInputValidator inputValidator= new IInputValidator() {
403	406	@Override
404	407	public String isValid(String newText) {
405	408	return (newText == null \|\| newText.trim().length() == 0) ? " " : null; //$NON-NLS-1$
406	409	}
407	410	};
408		InputDialog dialog= new InputDialog(fTextEditor.getSite().getShell(), title, message, proposal, inputValidator);
	411	AddBookmarkDialog dialog= new AddBookmarkDialog(fTextEditor.getSite().getShell(), title, message, proposal, inputValidator, addButtonText);
409	412
410	413	String label= null;
411	414	if (dialog.open() != Window.CANCEL)

420	423
421	424	MarkerUtilities.setMessage(attributes, label);
422	425	return true;
	426	}
	427
	428	class AddBookmarkDialog extends InputDialog {
	429
	430	private final String addButtonText;
	431
	432	public AddBookmarkDialog(Shell parentShell, String dialogTitle, String dialogMessage, String initialValue, IInputValidator validator, String addButtonText) {
	433	super(parentShell, dialogTitle, dialogMessage, initialValue, validator);
	434	this.addButtonText= addButtonText;
	435	}
	436
	437	@Override
	438	protected void createButtonsForButtonBar(Composite parent) {
	439	super.createButtonsForButtonBar(parent);
	440	Button okButton= getOkButton();
	441	okButton.setText(addButtonText);
	442	}
	443
423	444	}
424	445
425	446	/**

+3

-3

org.eclipse.ui.editors/src/org/eclipse/ui/texteditor/RevisionHoverInformationControlCreator.java less more

52	52	"dd { margin-top: 0; margin-bottom: 0 }\n" + //$NON-NLS-1$
53	53	"\n" + //$NON-NLS-1$
54	54	"/* Styles and colors */\n" + //$NON-NLS-1$
55		"a:link { color: #0000FF }\n" + //$NON-NLS-1$
56		"a:hover { color: #000080 }\n" + //$NON-NLS-1$
	55	"a:link { color: hyperlinkColor }\n" + //$NON-NLS-1$
	56	"a:hover { color: activeHyperlinkColor }\n" + //$NON-NLS-1$
57	57	"a:visited { text-decoration: underline }\n" + //$NON-NLS-1$
58	58	"h4 { font-style: italic }\n" + //$NON-NLS-1$
59	59	"strong { font-weight: bold }\n" + //$NON-NLS-1$

98	98	// there is already a header
99	99	return html;
100	100
101		StringBuffer info= new StringBuffer(512 + html.length());
	101	StringBuilder info= new StringBuilder(512 + html.length());
102	102	HTMLPrinter.insertPageProlog(info, 0, fgStyleSheet);
103	103	info.append(html);
104	104	HTMLPrinter.addPageEpilog(info);

+2

-1

org.eclipse.ui.editors.tests/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %Plugin.name
3	3	Bundle-SymbolicName: org.eclipse.ui.editors.tests;singleton:=true
4		Bundle-Version: 3.11.0.qualifier
	4	Bundle-Version: 3.11.100.qualifier
5	5	Bundle-Vendor: %Plugin.providerName
6	6	Bundle-Localization: plugin
7	7	Export-Package: org.eclipse.ui.editors.tests

22	22	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
23	23	Eclipse-BundleShape: dir
24	24	Bundle-ActivationPolicy: lazy
	25	Automatic-Module-Name: org.eclipse.ui.editors.tests

+2

-2

org.eclipse.ui.editors.tests/pom.xml less more

13	13	<parent>
14	14	<artifactId>tests-pom</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	<relativePath>../tests-pom/</relativePath>
18	18	</parent>
19	19	<groupId>org.eclipse.ui</groupId>
20	20	<artifactId>org.eclipse.ui.editors.tests</artifactId>
21		<version>3.11.0-SNAPSHOT</version>
	21	<version>3.11.100-SNAPSHOT</version>
22	22	<packaging>eclipse-test-plugin</packaging>
23	23	<properties>
24	24	<testSuite>${project.artifactId}</testSuite>

+58

-0

org.eclipse.ui.examples.javaeditor/.settings/org.eclipse.jdt.ui.prefs less more

0	0	eclipse.preferences.version=1
	1	editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
1	2	formatter_profile=_JDT UI Code Style Conventions
2	3	formatter_settings_version=12
3	4	org.eclipse.jdt.ui.exception.name=e

8	9	org.eclipse.jdt.ui.ondemandthreshold=99
9	10	org.eclipse.jdt.ui.overrideannotation=true
10	11	org.eclipse.jdt.ui.staticondemandthreshold=99
	12	sp_cleanup.add_default_serial_version_id=true
	13	sp_cleanup.add_generated_serial_version_id=false
	14	sp_cleanup.add_missing_annotations=true
	15	sp_cleanup.add_missing_deprecated_annotations=true
	16	sp_cleanup.add_missing_methods=false
	17	sp_cleanup.add_missing_nls_tags=false
	18	sp_cleanup.add_missing_override_annotations=true
	19	sp_cleanup.add_missing_override_annotations_interface_methods=true
	20	sp_cleanup.add_serial_version_id=false
	21	sp_cleanup.always_use_blocks=true
	22	sp_cleanup.always_use_parentheses_in_expressions=false
	23	sp_cleanup.always_use_this_for_non_static_field_access=false
	24	sp_cleanup.always_use_this_for_non_static_method_access=false
	25	sp_cleanup.convert_functional_interfaces=false
	26	sp_cleanup.convert_to_enhanced_for_loop=false
	27	sp_cleanup.correct_indentation=false
	28	sp_cleanup.format_source_code=true
	29	sp_cleanup.format_source_code_changes_only=true
	30	sp_cleanup.insert_inferred_type_arguments=false
	31	sp_cleanup.make_local_variable_final=true
	32	sp_cleanup.make_parameters_final=false
	33	sp_cleanup.make_private_fields_final=true
	34	sp_cleanup.make_type_abstract_if_missing_method=false
	35	sp_cleanup.make_variable_declarations_final=false
	36	sp_cleanup.never_use_blocks=false
	37	sp_cleanup.never_use_parentheses_in_expressions=true
	38	sp_cleanup.on_save_use_additional_actions=true
	39	sp_cleanup.organize_imports=true
	40	sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
	41	sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
	42	sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
	43	sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
	44	sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
	45	sp_cleanup.remove_private_constructors=true
	46	sp_cleanup.remove_redundant_type_arguments=false
	47	sp_cleanup.remove_trailing_whitespaces=false
	48	sp_cleanup.remove_trailing_whitespaces_all=true
	49	sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
	50	sp_cleanup.remove_unnecessary_casts=true
	51	sp_cleanup.remove_unnecessary_nls_tags=false
	52	sp_cleanup.remove_unused_imports=false
	53	sp_cleanup.remove_unused_local_variables=false
	54	sp_cleanup.remove_unused_private_fields=true
	55	sp_cleanup.remove_unused_private_members=false
	56	sp_cleanup.remove_unused_private_methods=true
	57	sp_cleanup.remove_unused_private_types=true
	58	sp_cleanup.sort_members=false
	59	sp_cleanup.sort_members_all=false
	60	sp_cleanup.use_anonymous_class_creation=false
	61	sp_cleanup.use_blocks=false
	62	sp_cleanup.use_blocks_only_for_return_and_throw=false
	63	sp_cleanup.use_lambda=true
	64	sp_cleanup.use_parentheses_in_expressions=false
	65	sp_cleanup.use_this_for_non_static_field_access=false
	66	sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true
	67	sp_cleanup.use_this_for_non_static_method_access=false
	68	sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true

+3

-4

org.eclipse.ui.examples.javaeditor/Eclipse Java Editor Example/org/eclipse/ui/examples/javaeditor/JavaContentOutlinePage.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2015 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

17	17	import org.eclipse.swt.widgets.Composite;
18	18	import org.eclipse.swt.widgets.Control;
19	19
20		import org.eclipse.jface.viewers.ISelection;
21	20	import org.eclipse.jface.viewers.IStructuredSelection;
22	21	import org.eclipse.jface.viewers.ITreeContentProvider;
23	22	import org.eclipse.jface.viewers.LabelProvider;

193	192
194	193	super.selectionChanged(event);
195	194
196		ISelection selection= event.getSelection();
	195	IStructuredSelection selection= event.getStructuredSelection();
197	196	if (selection.isEmpty())
198	197	fTextEditor.resetHighlightRange();
199	198	else {
200		Segment segment= (Segment) ((IStructuredSelection) selection).getFirstElement();
	199	Segment segment= (Segment) selection.getFirstElement();
201	200	int start= segment.position.getOffset();
202	201	int length= segment.position.getLength();
203	202	try {

+2

-1

org.eclipse.ui.examples.javaeditor/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %pluginName
3	3	Bundle-SymbolicName: org.eclipse.ui.examples.javaeditor; singleton:=true
4		Bundle-Version: 3.2.100.qualifier
	4	Bundle-Version: 3.2.200.qualifier
5	5	Bundle-Activator: org.eclipse.ui.examples.javaeditor.JavaEditorExamplePlugin
6	6	Bundle-Vendor: %providerName
7	7	Bundle-Localization: plugin

20	20	org.eclipse.ui.views
21	21	Bundle-ActivationPolicy: lazy
22	22	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
	23	Automatic-Module-Name: org.eclipse.ui.examples.javaeditor

+2

-2

org.eclipse.ui.examples.javaeditor/pom.xml less more

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<groupId>org.eclipse.ui</groupId>
19	19	<artifactId>org.eclipse.ui.examples.javaeditor</artifactId>
20		<version>3.2.100-SNAPSHOT</version>
	20	<version>3.2.200-SNAPSHOT</version>
21	21	<packaging>eclipse-plugin</packaging>
22	22	</project>

+17

-0

org.eclipse.ui.genericeditor/.settings/.api_filters less more

	0	<?xml version="1.0" encoding="UTF-8" standalone="no"?>
	1	<component id="org.eclipse.ui.genericeditor" version="2">
	2	<resource path="META-INF/MANIFEST.MF">
	3	<filter comment="Minor version was wrongly increased" id="926941240">
	4	<message_arguments>
	5	<message_argument value="1.1.0"/>
	6	<message_argument value="1.0.1"/>
	7	</message_arguments>
	8	</filter>
	9	<filter id="926941240">
	10	<message_arguments>
	11	<message_argument value="1.1.0"/>
	12	<message_argument value="1.0.2"/>
	13	</message_arguments>
	14	</filter>
	15	</resource>
	16	</component>

+59

-0

org.eclipse.ui.genericeditor/.settings/org.eclipse.jdt.ui.prefs less more

	0	eclipse.preferences.version=1
	1	editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
	2	sp_cleanup.add_default_serial_version_id=true
	3	sp_cleanup.add_generated_serial_version_id=false
	4	sp_cleanup.add_missing_annotations=true
	5	sp_cleanup.add_missing_deprecated_annotations=true
	6	sp_cleanup.add_missing_methods=false
	7	sp_cleanup.add_missing_nls_tags=false
	8	sp_cleanup.add_missing_override_annotations=true
	9	sp_cleanup.add_missing_override_annotations_interface_methods=true
	10	sp_cleanup.add_serial_version_id=false
	11	sp_cleanup.always_use_blocks=true
	12	sp_cleanup.always_use_parentheses_in_expressions=false
	13	sp_cleanup.always_use_this_for_non_static_field_access=false
	14	sp_cleanup.always_use_this_for_non_static_method_access=false
	15	sp_cleanup.convert_functional_interfaces=false
	16	sp_cleanup.convert_to_enhanced_for_loop=false
	17	sp_cleanup.correct_indentation=false
	18	sp_cleanup.format_source_code=true
	19	sp_cleanup.format_source_code_changes_only=false
	20	sp_cleanup.insert_inferred_type_arguments=false
	21	sp_cleanup.make_local_variable_final=true
	22	sp_cleanup.make_parameters_final=false
	23	sp_cleanup.make_private_fields_final=true
	24	sp_cleanup.make_type_abstract_if_missing_method=false
	25	sp_cleanup.make_variable_declarations_final=false
	26	sp_cleanup.never_use_blocks=false
	27	sp_cleanup.never_use_parentheses_in_expressions=true
	28	sp_cleanup.on_save_use_additional_actions=true
	29	sp_cleanup.organize_imports=true
	30	sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
	31	sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
	32	sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
	33	sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
	34	sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
	35	sp_cleanup.remove_private_constructors=true
	36	sp_cleanup.remove_redundant_type_arguments=false
	37	sp_cleanup.remove_trailing_whitespaces=false
	38	sp_cleanup.remove_trailing_whitespaces_all=true
	39	sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
	40	sp_cleanup.remove_unnecessary_casts=true
	41	sp_cleanup.remove_unnecessary_nls_tags=false
	42	sp_cleanup.remove_unused_imports=false
	43	sp_cleanup.remove_unused_local_variables=false
	44	sp_cleanup.remove_unused_private_fields=true
	45	sp_cleanup.remove_unused_private_members=false
	46	sp_cleanup.remove_unused_private_methods=true
	47	sp_cleanup.remove_unused_private_types=true
	48	sp_cleanup.sort_members=false
	49	sp_cleanup.sort_members_all=false
	50	sp_cleanup.use_anonymous_class_creation=false
	51	sp_cleanup.use_blocks=false
	52	sp_cleanup.use_blocks_only_for_return_and_throw=false
	53	sp_cleanup.use_lambda=true
	54	sp_cleanup.use_parentheses_in_expressions=false
	55	sp_cleanup.use_this_for_non_static_field_access=false
	56	sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true
	57	sp_cleanup.use_this_for_non_static_method_access=false
	58	sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true

+7

-4

org.eclipse.ui.genericeditor/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %Bundle-Name
3	3	Bundle-SymbolicName: org.eclipse.ui.genericeditor;singleton:=true
4		Bundle-Version: 1.0.2.qualifier
	4	Bundle-Version: 1.1.0.qualifier
5	5	Bundle-Vendor: %Bundle-Vendor
6	6	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
7	7	Require-Bundle: org.eclipse.ui.workbench.texteditor;bundle-version="3.10.0",
8	8	org.eclipse.ui.editors;bundle-version="3.10.0",
9	9	org.eclipse.text;bundle-version="3.6.0",
10		org.eclipse.jface.text;bundle-version="3.12.0",
	10	org.eclipse.jface.text;bundle-version="3.13.0",
11	11	org.eclipse.core.runtime;bundle-version="3.12.0",
12	12	org.eclipse.ui.workbench;bundle-version="3.109.0",
13	13	org.eclipse.jface;bundle-version="3.12.0",
14	14	org.eclipse.ui.ide;bundle-version="3.12.0",
15		org.eclipse.core.resources;bundle-version="3.11.0"
16		Export-Package: org.eclipse.ui.internal.genericeditor;x-internal:=true
	15	org.eclipse.core.resources;bundle-version="3.11.0",
	16	org.eclipse.core.expressions;bundle-version="3.6.0"
	17	Export-Package: org.eclipse.ui.internal.genericeditor;x-internal:=true,
	18	org.eclipse.ui.internal.genericeditor.hover;x-internal:=true,
	19	org.eclipse.ui.internal.genericeditor.markers;x-internal:=true
17	20	Bundle-Activator: org.eclipse.ui.internal.genericeditor.GenericEditorPlugin
18	21	Bundle-Localization: plugin
19	22	Bundle-ActivationPolicy: lazy

+2

-1

org.eclipse.ui.genericeditor/build.properties less more

14	14	plugin.xml,\
15	15	plugin.properties,\
16	16	about.html,\
17		icons/
	17	icons/,\
	18	resources/
18	19
19	20	src.includes = about.html,\
20	21	schema/

org.eclipse.ui.genericeditor/icons/full/dtool16/mark_occurrences.png less more

Binary diff not shown

org.eclipse.ui.genericeditor/icons/full/dtool16/mark_occurrences@2x.png less more

Binary diff not shown

org.eclipse.ui.genericeditor/icons/full/etool16/mark_occurrences.png less more

Binary diff not shown

org.eclipse.ui.genericeditor/icons/full/etool16/mark_occurrences@2x.png less more

Binary diff not shown

+9

-1

org.eclipse.ui.genericeditor/plugin.properties less more

6	6	#
7	7	# Contributors:
8	8	# Sopot Cela & Mickael Istria (Red Hat Inc.) - initial implementation
	9	# Lucas Bullen (Red Hat Inc.) - Bug 508829 custom reconciler support
	10	# - Bug 521382 default highlighter
	11	# Simon Scholz <simon.scholz@vogella.com> - Bug 527830
9	12	###############################################################################
10	13	genericEditor_name=Generic Text Editor
	14	ExtPoint.reconciliers=Reconciliers
11	15	ExtPoint.presentationReconciliers=Presentation Reconciliers
12	16	ExtPoint.hoverProviders= Hover Providers
13	17	ExtPoint.contentAssistProcessors=Content Assist Providers
	18	ExtPoint.autoEditStrategies=Auto Edit Strategies
	19	ExtPoint.highlightReconcilers=Highlight Reconcilers
14	20	ExtPoint.hyperlinkDetectorTarget=Generic Text Editor
15	21	openDeclarationCommand_name=Open Declaration
16	22	context_name=in Generic Code Editor

18	24	findReferencesCommand_name=Find References
19	25	findReferencesCommand_description=Find other code items referencing the current selected item.
20	26	Bundle-Vendor=Eclipse.org
21		Bundle-Name=Generic and Extensible Text Editor⏎
	27	Bundle-Name=Generic and Extensible Text Editor
	28	command.toggle.highlight.label = Toggle Mark Occurences
	29	command.toggle.highlight.name = Toggle Highlight⏎

+94

-1

org.eclipse.ui.genericeditor/plugin.xml less more

0	0	<?xml version="1.0" encoding="UTF-8"?>
1	1	<?eclipse version="3.4"?>
2	2	<!-- ====================================================================== -->
3		<!-- Copyright (c) 2016 Red Hat Inc. and others. -->
	3	<!-- Copyright (c) 2016, 2017 Red Hat Inc. and others. -->
4	4	<!-- All rights reserved. This program and the accompanying materials -->
5	5	<!-- are made available under the terms of the Eclipse Public License v1.0 -->
6	6	<!-- which accompanies this distribution, and is available at -->

8	8	<!-- -->
9	9	<!-- Contributors: -->
10	10	<!-- Sopot Cela & Mickael Istria (Red Hat Inc). -initial implementation -->
	11	<!-- Lucas Bullen (Red Hat Inc.) - Bug 508829 custom reconciler support -->
	12	<!-- - Bug 521382 default highlighter -->
	13	<!-- Simon Scholz <simon.scholz@vogella.com> - Bug 527830 -->
11	14	<!-- ====================================================================== -->
12	15	<plugin>
	16	<extension-point id="reconcilers" name="%ExtPoint.reconciliers" schema="schema/reconcilers.exsd"/>
13	17	<extension-point id="presentationReconcilers" name="%ExtPoint.presentationReconciliers" schema="schema/presentationReconcilers.exsd"/>
14	18	<extension-point id="contentAssistProcessors" name="%ExtPoint.contentAssistProcessors" schema="schema/contentAssistProcessors.exsd"/>
15	19	<extension-point id="hoverProviders" name="%ExtPoint.hoverProviders" schema="schema/hoverProviders.exsd"/>
	20	<extension-point id="autoEditStrategies" name="%ExtPoint.autoEditStrategies" schema="schema/autoEditStrategies.exsd"/>
	21	<extension-point id="highlightReconcilers" name="%ExtPoint.highlightReconcilers" schema="schema/highlightReconcilers.exsd"/>
16	22	<extension
17	23	point="org.eclipse.ui.editors">
18	24	<editor

33	39	description="%findReferencesCommand_description"
34	40	id="org.eclipse.ui.genericeditor.findReferences"
35	41	name="%findReferencesCommand_name">
	42	</command>
	43	<command
	44	id="org.eclipse.ui.genericeditor.togglehighlight"
	45	name="%command.toggle.highlight.name">
	46	<state
	47	class="org.eclipse.ui.handlers.RegistryToggleState:true"
	48	id="org.eclipse.ui.commands.toggleState">
	49	</state>
36	50	</command>
37	51	</extension>
38	52	<extension

69	83	style="push">
70	84	</command>
71	85	</menuContribution>
	86	<menuContribution
	87	allPopups="false"
	88	locationURI="toolbar:org.eclipse.ui.edit.text.actionSet.presentation">
	89	<command
	90	commandId="org.eclipse.ui.genericeditor.togglehighlight"
	91	label="%command.toggle.highlight.label"
	92	style="toggle">
	93	<visibleWhen>
	94	<reference
	95	definitionId="org.eclipse.ui.genericeditor.GenericEditor.active">
	96	</reference>
	97	</visibleWhen>
	98	</command>
	99	</menuContribution>
	100	</extension>
	101	<extension
	102	point="org.eclipse.ui.handlers">
	103	<handler
	104	commandId="org.eclipse.ui.genericeditor.togglehighlight">
	105	<class
	106	class="org.eclipse.ui.internal.genericeditor.ToggleHighlight"></class>
	107	</handler>
72	108	</extension>
73	109	<extension
74	110	point="org.eclipse.ui.genericeditor.hoverProviders">

87	123	</hoverProvider>
88	124	</extension>
89	125	<extension
	126	point="org.eclipse.ui.commandImages">
	127	<image
	128	commandId="org.eclipse.ui.genericeditor.togglehighlight"
	129	disabledIcon="icons/full/dtool16/mark_occurrences.png"
	130	icon="icons/full/etool16/mark_occurrences.png">
	131	</image>
	132	</extension>
	133	<extension point="org.eclipse.ui.editors.annotationTypes">
	134	<type name="org.eclipse.ui.genericeditor.text"></type>
	135	</extension>
	136	<extension point="org.eclipse.ui.editors.markerAnnotationSpecification">
	137	<specification annotationType="org.eclipse.ui.genericeditor.text"
	138	label="Text Occurrence"
	139	textPreferenceKey="TextOccurrenceIndication" textPreferenceValue="false"
	140	highlightPreferenceKey="TextOccurrenceHighlighting"
	141	highlightPreferenceValue="true" contributesToHeader="false"
	142	overviewRulerPreferenceKey="TextOccurrenceIndicationInOverviewRuler"
	143	overviewRulerPreferenceValue="true"
	144	verticalRulerPreferenceKey="TextOccurrenceIndicationInVerticalRuler"
	145	verticalRulerPreferenceValue="false" colorPreferenceKey="TextOccurrenceIndicationColor"
	146	colorPreferenceValue="212,212,212" presentationLayer="4"
	147	showInNextPrevDropdownToolbarAction="true"
	148	textStylePreferenceKey="TextOccurrenceTextStyle"
	149	textStylePreferenceValue="NONE">
	150	</specification>
	151	</extension>
	152	<extension
	153	point="org.eclipse.e4.ui.css.swt.theme">
	154	<stylesheet
	155	uri="resources/css/dark.css">
	156	<themeid
	157	refid="org.eclipse.e4.ui.css.theme.e4_dark">
	158	</themeid>
	159	</stylesheet>
	160	</extension>
	161	<extension
90	162	point="org.eclipse.ui.workbench.texteditor.hyperlinkDetectorTargets">
91	163	<target
92	164	id="org.eclipse.ui.genericeditor.GenericEditor"

96	168	</context>
97	169	</target>
98	170	</extension>
	171	<extension
	172	point="org.eclipse.ui.actionSetPartAssociations">
	173	<actionSetPartAssociation
	174	targetID="org.eclipse.ui.edit.text.actionSet.presentation">
	175	<part
	176	id="org.eclipse.ui.genericeditor.GenericEditor">
	177	</part>
	178	</actionSetPartAssociation>
	179	</extension>
	180	<extension
	181	point="org.eclipse.core.expressions.definitions">
	182	<definition
	183	id="org.eclipse.ui.genericeditor.GenericEditor.active">
	184	<with
	185	variable="activeEditorId">
	186	<equals
	187	value="org.eclipse.ui.genericeditor.GenericEditor">
	188	</equals>
	189	</with>
	190	</definition>
	191	</extension>
99	192	</plugin>

+2

-2

org.eclipse.ui.genericeditor/pom.xml less more

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<groupId>org.eclipse.ui</groupId>
19	19	<artifactId>org.eclipse.ui.genericeditor</artifactId>
20		<version>1.0.2-SNAPSHOT</version>
	20	<version>1.1.0-SNAPSHOT</version>
21	21	<packaging>eclipse-plugin</packaging>
22	22	</project>

+16

-0

org.eclipse.ui.genericeditor/resources/css/dark.css less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10
	11	IEclipsePreferences#org-eclipse-ui-editors:org-eclipse-ui-genericeditor {
	12	preferences:
	13	'TextOccurrenceIndicationColor=27, 98, 145'
	14	}
	15

+154

-0

org.eclipse.ui.genericeditor/schema/autoEditStrategies.exsd less more

	0	<?xml version='1.0' encoding='UTF-8'?>
	1	<!-- Schema file written by PDE -->
	2	<schema targetNamespace="org.eclipse.ui.genericeditor" xmlns="http://www.w3.org/2001/XMLSchema">
	3	<annotation>
	4	<appinfo>
	5	<meta.schema plugin="org.eclipse.ui.genericeditor" id="autoEditStrategies" name="Auto edit strategies"/>
	6	</appinfo>
	7	<documentation>
	8	This extension point is used to contribute auto edit strategies for a given content type.
	9	</documentation>
	10	</annotation>
	11
	12	<include schemaLocation="schema://org.eclipse.core.expressions/schema/expressionLanguage.exsd"/>
	13
	14	<element name="extension">
	15	<annotation>
	16	<appinfo>
	17	<meta.element />
	18	</appinfo>
	19	</annotation>
	20	<complexType>
	21	<sequence minOccurs="1" maxOccurs="unbounded">
	22	<element ref="autoEditStrategy"/>
	23	</sequence>
	24	<attribute name="point" type="string" use="required">
	25	<annotation>
	26	<documentation>
	27	a fully qualified identifier of the target extension point
	28	</documentation>
	29	</annotation>
	30	</attribute>
	31	<attribute name="id" type="string">
	32	<annotation>
	33	<documentation>
	34	an optional identifier of the extension instance
	35	</documentation>
	36	</annotation>
	37	</attribute>
	38	<attribute name="name" type="string">
	39	<annotation>
	40	<documentation>
	41	an optional name of the extension instance
	42	</documentation>
	43	<appinfo>
	44	<meta.attribute translatable="true"/>
	45	</appinfo>
	46	</annotation>
	47	</attribute>
	48	</complexType>
	49	</element>
	50
	51	<element name="autoEditStrategy">
	52	<complexType>
	53	<sequence>
	54	<element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
	55	</sequence>
	56	<attribute name="class" type="string" use="required">
	57	<annotation>
	58	<documentation>
	59	The fully qualified class name implementing the interface <code>org.eclipse.jface.text.IAutoEditStrategy</code>
	60	</documentation>
	61	<appinfo>
	62	<meta.attribute kind="java" basedOn=":org.eclipse.jface.text.IAutoEditStrategy"/>
	63	</appinfo>
	64	</annotation>
	65	</attribute>
	66	<attribute name="contentType" type="string" use="required">
	67	<annotation>
	68	<documentation>
	69	The target content-type for this extension. Content-types are defined as extension to the org.eclipse.core.contenttype.contentTypes extension point.
	70	</documentation>
	71	<appinfo>
	72	<meta.attribute kind="identifier" basedOn="org.eclipse.core.contenttype.contentTypes/content-type/@id"/>
	73	</appinfo>
	74	</annotation>
	75	</attribute>
	76	</complexType>
	77	</element>
	78
	79	<element name="enabledWhen">
	80	<annotation>
	81	<documentation>
	82	A core Expression that controls the enabled of the given auto edit strategies. The viewer, editor, and editor input are registered in the evaluation context as variable:
	83
	84	* <with variable="viewer"/> : use it if your expression requires the viewer.
	85	* <with variable="editor"/> : use it if your expression requires the editor.
	86	* <with variable="editorInput"/> : use it if your expression requires the editor input.
	87	</documentation>
	88	</annotation>
	89	<complexType>
	90	<choice minOccurs="0" maxOccurs="1">
	91	<element ref="not"/>
	92	<element ref="or"/>
	93	<element ref="and"/>
	94	<element ref="instanceof"/>
	95	<element ref="test"/>
	96	<element ref="systemTest"/>
	97	<element ref="equals"/>
	98	<element ref="count"/>
	99	<element ref="with"/>
	100	<element ref="resolve"/>
	101	<element ref="adapt"/>
	102	<element ref="iterate"/>
	103	<element ref="reference"/>
	104	</choice>
	105	</complexType>
	106	</element>
	107
	108	<annotation>
	109	<appinfo>
	110	<meta.section type="since"/>
	111	</appinfo>
	112	<documentation>
	113	1.0
	114	</documentation>
	115	</annotation>
	116
	117	<annotation>
	118	<appinfo>
	119	<meta.section type="examples"/>
	120	</appinfo>
	121	<documentation>
	122	This is an example of a strategy being registered for a target definition file type:
	123
	124	<pre>
	125	<extension point="org.eclipse.ui.genericeditor.autoEditStrategies">
	126	<autoEditStrategy
	127	class="org.eclipse.ui.genericeditor.examples.TargetDefinitionAutoEditStrategy"
	128	contentType="org.eclipse.pde.targetFile">
	129	<enabledWhen>
	130	<with variable="editor">
	131	<test property="org.eclipse.ui.genericeditor.examples.TargetDefinitionPropertyTester">
	132	</test>
	133	</with>
	134	</enabledWhen>
	135	</autoEditStrategy>
	136	</extension>
	137	</pre>
	138	</documentation>
	139	</annotation>
	140
	141
	142
	143	<annotation>
	144	<appinfo>
	145	<meta.section type="copyright"/>
	146	</appinfo>
	147	<documentation>
	148	Copyright (c) 2017 Rogue Wave Software Inc. and others
	149	All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
	150	</documentation>
	151	</annotation>
	152
	153	</schema>

+40

-2

org.eclipse.ui.genericeditor/schema/contentAssistProcessors.exsd less more

50	50
51	51	<element name="contentAssistProcessor">
52	52	<complexType>
	53	<sequence>
	54	<element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
	55	</sequence>
53	56	<attribute name="class" type="string" use="required">
54	57	<annotation>
55	58	<documentation>

73	76	</complexType>
74	77	</element>
75	78
	79	<element name="enabledWhen">
	80	<annotation>
	81	<documentation>
	82	A core Expression that controls the enabled of the given content assist processor. The viewer, editor, and editor input are registered in the evaluation context as variable:
	83
	84	* <with variable="viewer"/> : use it if your expression requires the viewer.
	85	* <with variable="editor"/> : use it if your expression requires the editor.
	86	* <with variable="editorInput"/> : use it if your expression requires the editor input.
	87	</documentation>
	88	</annotation>
	89	<complexType>
	90	<choice minOccurs="0" maxOccurs="1">
	91	<element ref="not"/>
	92	<element ref="or"/>
	93	<element ref="and"/>
	94	<element ref="instanceof"/>
	95	<element ref="test"/>
	96	<element ref="systemTest"/>
	97	<element ref="equals"/>
	98	<element ref="count"/>
	99	<element ref="with"/>
	100	<element ref="resolve"/>
	101	<element ref="adapt"/>
	102	<element ref="iterate"/>
	103	<element ref="reference"/>
	104	</choice>
	105	</complexType>
	106	</element>
	107
76	108	<annotation>
77	109	<appinfo>
78	110	<meta.section type="since"/>

92	124	<pre>
93	125	<extension point="org.eclipse.ui.genericeditor.contentAssistProcessors">
94	126	<contentAssistProcessor
95		class="org.eclipse.ui.genericeditor.examples.TargedDefinitionContentAssist"
96		contentType="org.eclipse.pde.targetFile">
	127	class="org.eclipse.ui.genericeditor.examples.TargedDefinitionContentAssist"
	128	contentType="org.eclipse.pde.targetFile">
	129	<enabledWhen>
	130	<with variable="editor">
	131	<test property="org.eclipse.ui.genericeditor.examples.TargetDefinitionPropertyTester">
	132	</test>
	133	</with>
	134	</enabledWhen>
97	135	</contentAssistProcessor>
98	136	</extension>
99	137	</pre>

+154

-0

org.eclipse.ui.genericeditor/schema/highlightReconcilers.exsd less more

	0	<?xml version='1.0' encoding='UTF-8'?>
	1	<!-- Schema file written by PDE -->
	2	<schema targetNamespace="org.eclipse.ui.genericeditor" xmlns="http://www.w3.org/2001/XMLSchema">
	3	<annotation>
	4	<appinfo>
	5	<meta.schema plugin="org.eclipse.ui.genericeditor" id="highlightReconcilers" name="Highlight reconcilers"/>
	6	</appinfo>
	7	<documentation>
	8	This extension point is used to contribute highlight reconcilers for controlling the highlighting on a file with a given content type. Reconcilers attached to this extension point that listen to the preference "org.eclipse.ui.genericeditor.togglehighlight" will be toggled with the "Toggle Mark Occurences" button.
	9	</documentation>
	10	</annotation>
	11
	12	<include schemaLocation="schema://org.eclipse.core.expressions/schema/expressionLanguage.exsd"/>
	13
	14	<element name="extension">
	15	<annotation>
	16	<appinfo>
	17	<meta.element />
	18	</appinfo>
	19	</annotation>
	20	<complexType>
	21	<sequence minOccurs="1" maxOccurs="unbounded">
	22	<element ref="highlightReconciler"/>
	23	</sequence>
	24	<attribute name="point" type="string" use="required">
	25	<annotation>
	26	<documentation>
	27	a fully qualified identifier of the target extension point
	28	</documentation>
	29	</annotation>
	30	</attribute>
	31	<attribute name="id" type="string">
	32	<annotation>
	33	<documentation>
	34	an optional identifier of the extension instance
	35	</documentation>
	36	</annotation>
	37	</attribute>
	38	<attribute name="name" type="string">
	39	<annotation>
	40	<documentation>
	41	an optional name of the extension instance
	42	</documentation>
	43	<appinfo>
	44	<meta.attribute translatable="true"/>
	45	</appinfo>
	46	</annotation>
	47	</attribute>
	48	</complexType>
	49	</element>
	50
	51	<element name="highlightReconciler">
	52	<complexType>
	53	<sequence>
	54	<element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
	55	</sequence>
	56	<attribute name="class" type="string" use="required">
	57	<annotation>
	58	<documentation>
	59	The fully qualified class name implementing the interface <code>org.eclipse.jface.text.reconciler.IReconciler</code>
	60	</documentation>
	61	<appinfo>
	62	<meta.attribute kind="java" basedOn=":org.eclipse.jface.text.reconciler.IReconciler"/>
	63	</appinfo>
	64	</annotation>
	65	</attribute>
	66	<attribute name="contentType" type="string" use="required">
	67	<annotation>
	68	<documentation>
	69	The target content-type for this extension. Content-types are defined as extension to the org.eclipse.core.contenttype.contentTypes extension point.
	70	</documentation>
	71	<appinfo>
	72	<meta.attribute kind="identifier" basedOn="org.eclipse.core.contenttype.contentTypes/content-type/@id"/>
	73	</appinfo>
	74	</annotation>
	75	</attribute>
	76	</complexType>
	77	</element>
	78
	79	<element name="enabledWhen">
	80	<annotation>
	81	<documentation>
	82	A core Expression that controls the enabled of the given highlight reconciler. The viewer, editor, and editor input are registered in the evaluation context as variable:
	83
	84	* <with variable="viewer"/> : use it if your expression requires the viewer.
	85	* <with variable="editor"/> : use it if your expression requires the editor.
	86	* <with variable="editorInput"/> : use it if your expression requires the editor input.
	87	</documentation>
	88	</annotation>
	89	<complexType>
	90	<choice minOccurs="0" maxOccurs="1">
	91	<element ref="not"/>
	92	<element ref="or"/>
	93	<element ref="and"/>
	94	<element ref="instanceof"/>
	95	<element ref="test"/>
	96	<element ref="systemTest"/>
	97	<element ref="equals"/>
	98	<element ref="count"/>
	99	<element ref="with"/>
	100	<element ref="resolve"/>
	101	<element ref="adapt"/>
	102	<element ref="iterate"/>
	103	<element ref="reference"/>
	104	</choice>
	105	</complexType>
	106	</element>
	107
	108	<annotation>
	109	<appinfo>
	110	<meta.section type="since"/>
	111	</appinfo>
	112	<documentation>
	113	1.1
	114	</documentation>
	115	</annotation>
	116
	117	<annotation>
	118	<appinfo>
	119	<meta.section type="examples"/>
	120	</appinfo>
	121	<documentation>
	122	Below is an example of how to use the Highlight Reconciler extension point:
	123
	124	<pre>
	125	<extension point="org.eclipse.ui.genericeditor.highlightReconcilers">
	126	<highlightReconciler
	127	class="org.eclipse.ui.genericeditor.examples.TargetDefinitionHighlightReconciler"
	128	contentType="org.eclipse.pde.targetFile">
	129	<enabledWhen>
	130	<with variable="editor">
	131	<test property="org.eclipse.ui.genericeditor.examples.TargetDefinitionPropertyTester">
	132	</test>
	133	</with>
	134	</enabledWhen>
	135	</highlightReconciler>
	136	</extension>
	137	</pre>
	138	</documentation>
	139	</annotation>
	140
	141
	142
	143	<annotation>
	144	<appinfo>
	145	<meta.section type="copyright"/>
	146	</appinfo>
	147	<documentation>
	148	Copyright (c) 2017 Red Hat Inc. and others
	149	All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
	150	</documentation>
	151	</annotation>
	152
	153	</schema>

+42

-4

org.eclipse.ui.genericeditor/schema/hoverProviders.exsd less more

50	50
51	51	<element name="hoverProvider">
52	52	<complexType>
	53	<sequence>
	54	<element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
	55	</sequence>
53	56	<attribute name="id" type="string">
54	57	<annotation>
55	58	<documentation>

102	105	</complexType>
103	106	</element>
104	107
	108	<element name="enabledWhen">
	109	<annotation>
	110	<documentation>
	111	A core Expression that controls the enabled of the given hover provider. The viewer, editor, and editor input are registered in the evaluation context as variable:
	112
	113	* <with variable="viewer"/> : use it if your expression requires the viewer.
	114	* <with variable="editor"/> : use it if your expression requires the editor.
	115	* <with variable="editorInput"/> : use it if your expression requires the editor input.
	116	</documentation>
	117	</annotation>
	118	<complexType>
	119	<choice minOccurs="0" maxOccurs="1">
	120	<element ref="not"/>
	121	<element ref="or"/>
	122	<element ref="and"/>
	123	<element ref="instanceof"/>
	124	<element ref="test"/>
	125	<element ref="systemTest"/>
	126	<element ref="equals"/>
	127	<element ref="count"/>
	128	<element ref="with"/>
	129	<element ref="resolve"/>
	130	<element ref="adapt"/>
	131	<element ref="iterate"/>
	132	<element ref="reference"/>
	133	</choice>
	134	</complexType>
	135	</element>
	136
105	137	<annotation>
106	138	<appinfo>
107	139	<meta.section type="since"/>

120	152
121	153	<pre>
122	154	<extension point="org.eclipse.ui.genericeditor.hoverProviders">
123		<hoverProvider
124		class="org.eclipse.ui.genericeditor.tests.contributions.MagicHoverProvider"
125		contentType="org.eclipse.core.runtime.text">
126		</hoverProvider>
	155	<hoverProvider
	156	class="org.eclipse.ui.genericeditor.examples.TargetDefinitionHoverProvider"
	157	contentType="org.eclipse.pde.targetFile">
	158	<enabledWhen>
	159	<with variable="editor">
	160	<test property="org.eclipse.ui.genericeditor.examples.TargetDefinitionPropertyTester">
	161	</test>
	162	</with>
	163	</enabledWhen>
	164	</hoverProvider>
127	165	</extension>
128	166	</pre>
129	167	</documentation>

+42

-4

org.eclipse.ui.genericeditor/schema/presentationReconcilers.exsd less more

50	50
51	51	<element name="presentationReconciler">
52	52	<complexType>
	53	<sequence>
	54	<element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
	55	</sequence>
53	56	<attribute name="class" type="string" use="required">
54	57	<annotation>
55	58	<documentation>

73	76	</complexType>
74	77	</element>
75	78
	79	<element name="enabledWhen">
	80	<annotation>
	81	<documentation>
	82	A core Expression that controls the enabled of the given presentation reconciler. The viewer, editor, and editor input are registered in the evaluation context as variable:
	83
	84	* <with variable="viewer"/> : use it if your expression requires the viewer.
	85	* <with variable="editor"/> : use it if your expression requires the editor.
	86	* <with variable="editorInput"/> : use it if your expression requires the editor input.
	87	</documentation>
	88	</annotation>
	89	<complexType>
	90	<choice minOccurs="0" maxOccurs="1">
	91	<element ref="not"/>
	92	<element ref="or"/>
	93	<element ref="and"/>
	94	<element ref="instanceof"/>
	95	<element ref="test"/>
	96	<element ref="systemTest"/>
	97	<element ref="equals"/>
	98	<element ref="count"/>
	99	<element ref="with"/>
	100	<element ref="resolve"/>
	101	<element ref="adapt"/>
	102	<element ref="iterate"/>
	103	<element ref="reference"/>
	104	</choice>
	105	</complexType>
	106	</element>
	107
76	108	<annotation>
77	109	<appinfo>
78	110	<meta.section type="since"/>

91	123
92	124	<pre>
93	125	<extension point="org.eclipse.ui.genericeditor.presentationReconcilers">
94		<presentationReconciler
95		class="org.eclipse.ui.genericeditor.examples.TPPresentationReconciler"
96		contentType="org.eclipse.pde.targetFile">
97		</presentationReconciler>
	126	<presentationReconciler
	127	class="org.eclipse.ui.genericeditor.examples.TargetDefinitionPresentationReconciler"
	128	contentType="org.eclipse.pde.targetFile">
	129	<enabledWhen>
	130	<with variable="editor">
	131	<test property="org.eclipse.ui.genericeditor.examples.TargetDefinitionPropertyTester">
	132	</test>
	133	</with>
	134	</enabledWhen>
	135	</presentationReconciler>
98	136	</extension>
99	137	</pre>
100	138	</documentation>

+154

-0

org.eclipse.ui.genericeditor/schema/reconcilers.exsd less more

	0	<?xml version='1.0' encoding='UTF-8'?>
	1	<!-- Schema file written by PDE -->
	2	<schema targetNamespace="org.eclipse.ui.genericeditor" xmlns="http://www.w3.org/2001/XMLSchema">
	3	<annotation>
	4	<appinfo>
	5	<meta.schema plugin="org.eclipse.ui.genericeditor" id="reconcilers" name="Reconcilers"/>
	6	</appinfo>
	7	<documentation>
	8	This extension point is used to contribute reconcilers for controlling the presentation on a file with a given content type.
	9	</documentation>
	10	</annotation>
	11
	12	<include schemaLocation="schema://org.eclipse.core.expressions/schema/expressionLanguage.exsd"/>
	13
	14	<element name="extension">
	15	<annotation>
	16	<appinfo>
	17	<meta.element />
	18	</appinfo>
	19	</annotation>
	20	<complexType>
	21	<sequence minOccurs="1" maxOccurs="unbounded">
	22	<element ref="reconciler"/>
	23	</sequence>
	24	<attribute name="point" type="string" use="required">
	25	<annotation>
	26	<documentation>
	27	a fully qualified identifier of the target extension point
	28	</documentation>
	29	</annotation>
	30	</attribute>
	31	<attribute name="id" type="string">
	32	<annotation>
	33	<documentation>
	34	an optional identifier of the extension instance
	35	</documentation>
	36	</annotation>
	37	</attribute>
	38	<attribute name="name" type="string">
	39	<annotation>
	40	<documentation>
	41	an optional name of the extension instance
	42	</documentation>
	43	<appinfo>
	44	<meta.attribute translatable="true"/>
	45	</appinfo>
	46	</annotation>
	47	</attribute>
	48	</complexType>
	49	</element>
	50
	51	<element name="reconciler">
	52	<complexType>
	53	<sequence>
	54	<element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
	55	</sequence>
	56	<attribute name="class" type="string" use="required">
	57	<annotation>
	58	<documentation>
	59	The fully qualified class name implementing the interface <code>org.eclipse.jface.text.reconciler.IReconciler</code>
	60	</documentation>
	61	<appinfo>
	62	<meta.attribute kind="java" basedOn=":org.eclipse.jface.text.reconciler.IReconciler"/>
	63	</appinfo>
	64	</annotation>
	65	</attribute>
	66	<attribute name="contentType" type="string" use="required">
	67	<annotation>
	68	<documentation>
	69	The target content-type for this extension. Content-types are defined as extension to the org.eclipse.core.contenttype.contentTypes extension point.
	70	</documentation>
	71	<appinfo>
	72	<meta.attribute kind="identifier" basedOn="org.eclipse.core.contenttype.contentTypes/content-type/@id"/>
	73	</appinfo>
	74	</annotation>
	75	</attribute>
	76	</complexType>
	77	</element>
	78
	79	<element name="enabledWhen">
	80	<annotation>
	81	<documentation>
	82	A core Expression that controls the enabled of the given reconciler. The viewer, editor, and editor input are registered in the evaluation context as variable:
	83
	84	* <with variable="viewer"/> : use it if your expression requires the viewer.
	85	* <with variable="editor"/> : use it if your expression requires the editor.
	86	* <with variable="editorInput"/> : use it if your expression requires the editor input.
	87	</documentation>
	88	</annotation>
	89	<complexType>
	90	<choice minOccurs="0" maxOccurs="1">
	91	<element ref="not"/>
	92	<element ref="or"/>
	93	<element ref="and"/>
	94	<element ref="instanceof"/>
	95	<element ref="test"/>
	96	<element ref="systemTest"/>
	97	<element ref="equals"/>
	98	<element ref="count"/>
	99	<element ref="with"/>
	100	<element ref="resolve"/>
	101	<element ref="adapt"/>
	102	<element ref="iterate"/>
	103	<element ref="reference"/>
	104	</choice>
	105	</complexType>
	106	</element>
	107
	108	<annotation>
	109	<appinfo>
	110	<meta.section type="since"/>
	111	</appinfo>
	112	<documentation>
	113	1.1
	114	</documentation>
	115	</annotation>
	116
	117	<annotation>
	118	<appinfo>
	119	<meta.section type="examples"/>
	120	</appinfo>
	121	<documentation>
	122	Below is an example of how to use the Reconciler extension point:
	123
	124	<pre>
	125	<extension point="org.eclipse.ui.genericeditor.reconcilers">
	126	<reconciler
	127	class="org.eclipse.ui.genericeditor.examples.TargetDefinitionReconciler"
	128	contentType="org.eclipse.pde.targetFile">
	129	<enabledWhen>
	130	<with variable="editor">
	131	<test property="org.eclipse.ui.genericeditor.examples.TargetDefinitionPropertyTester">
	132	</test>
	133	</with>
	134	</enabledWhen>
	135	</reconciler>
	136	</extension>
	137	</pre>
	138	</documentation>
	139	</annotation>
	140
	141
	142
	143	<annotation>
	144	<appinfo>
	145	<meta.section type="copyright"/>
	146	</appinfo>
	147	<documentation>
	148	Copyright (c) 2017 Red Hat Inc. and others
	149	All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
	150	</documentation>
	151	</annotation>
	152
	153	</schema>

+100

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/AutoEditStrategyRegistry.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Rogue Wave Software Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Michał Niewrzał (Rogue Wave Software Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import java.util.HashSet;
	13	import java.util.LinkedHashMap;
	14	import java.util.List;
	15	import java.util.Map;
	16	import java.util.Set;
	17	import java.util.stream.Collectors;
	18
	19	import org.eclipse.core.runtime.IConfigurationElement;
	20	import org.eclipse.core.runtime.IRegistryChangeEvent;
	21	import org.eclipse.core.runtime.IRegistryChangeListener;
	22	import org.eclipse.core.runtime.IStatus;
	23	import org.eclipse.core.runtime.Platform;
	24	import org.eclipse.core.runtime.Status;
	25	import org.eclipse.core.runtime.content.IContentType;
	26	import org.eclipse.jface.text.IAutoEditStrategy;
	27	import org.eclipse.jface.text.source.ISourceViewer;
	28	import org.eclipse.ui.texteditor.ITextEditor;
	29
	30	/**
	31	* A registry of auto edit strategies provided by extension
	32	* <code>org.eclipse.ui.genericeditor.autoEditStrategy</code>. Those extensions
	33	* are specific to a given {@link IContentType}.
	34	*
	35	* @since 1.1
	36	*/
	37	public class AutoEditStrategyRegistry {
	38
	39	private static final String EXTENSION_POINT_ID = GenericEditorPlugin.BUNDLE_ID + ".autoEditStrategies"; //$NON-NLS-1$
	40
	41	private Map<IConfigurationElement, GenericContentTypeRelatedExtension<IAutoEditStrategy>> extensions = new LinkedHashMap<>();
	42	private boolean outOfSync = true;
	43
	44	/**
	45	* Creates the registry and binds it to the extension point.
	46	*/
	47	public AutoEditStrategyRegistry() {
	48	Platform.getExtensionRegistry().addRegistryChangeListener(new IRegistryChangeListener() {
	49	@Override
	50	public void registryChanged(IRegistryChangeEvent event) {
	51	outOfSync = true;
	52	}
	53	}, EXTENSION_POINT_ID);
	54	}
	55
	56	/**
	57	* Get the contributed {@link IAutoEditStrategy}s that are relevant to hook
	58	* on source viewer according to document content types.
	59	*
	60	* @param sourceViewer
	61	* the source viewer we're hooking completion to.
	62	* @param editor the text editor
	63	* @param contentTypes
	64	* the content types of the document we're editing.
	65	* @return the list of {@link IAutoEditStrategy} contributed for at least
	66	* one of the content types.
	67	*/
	68	public List<IAutoEditStrategy> getAutoEditStrategies(ISourceViewer sourceViewer, ITextEditor editor, Set<IContentType> contentTypes) {
	69	if (this.outOfSync) {
	70	sync();
	71	}
	72	return this.extensions.values().stream()
	73	.filter(ext -> contentTypes.contains(ext.targetContentType))
	74	.filter(ext -> ext.matches(sourceViewer, editor))
	75	.sorted(new ContentTypeSpecializationComparator<IAutoEditStrategy>())
	76	.map(GenericContentTypeRelatedExtension<IAutoEditStrategy>::createDelegate)
	77	.collect(Collectors.toList());
	78	}
	79
	80	private void sync() {
	81	Set<IConfigurationElement> toRemoveExtensions = new HashSet<>(this.extensions.keySet());
	82	for (IConfigurationElement extension : Platform.getExtensionRegistry()
	83	.getConfigurationElementsFor(EXTENSION_POINT_ID)) {
	84	toRemoveExtensions.remove(extension);
	85	if (!this.extensions.containsKey(extension)) {
	86	try {
	87	this.extensions.put(extension, new GenericContentTypeRelatedExtension<IAutoEditStrategy>(extension));
	88	} catch (Exception ex) {
	89	GenericEditorPlugin.getDefault().getLog()
	90	.log(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID, ex.getMessage(), ex));
	91	}
	92	}
	93	}
	94	for (IConfigurationElement toRemove : toRemoveExtensions) {
	95	this.extensions.remove(toRemove);
	96	}
	97	this.outOfSync = false;
	98	}
	99	}

+4

-1

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/CompositeContentAssistProcessor.java less more

45	45	public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
46	46	List<ICompletionProposal> res = new ArrayList<>();
47	47	for (IContentAssistProcessor processor : this.fContentAssistProcessors) {
48		res.addAll(Arrays.asList(processor.computeCompletionProposals(viewer, offset)));
	48	ICompletionProposal[] proposals = processor.computeCompletionProposals(viewer, offset);
	49	if (proposals != null) {
	50	res.addAll(Arrays.asList(proposals));
	51	}
49	52	}
50	53	return res.toArray(new ICompletionProposal[res.size()]);
51	54	}

+81

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/CompositeReconciler.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import java.util.ArrayList;
	13	import java.util.List;
	14	import java.util.Objects;
	15	import java.util.stream.Collectors;
	16
	17	import org.eclipse.jface.text.IDocumentExtension3;
	18	import org.eclipse.jface.text.ITextViewer;
	19	import org.eclipse.jface.text.reconciler.IReconciler;
	20	import org.eclipse.jface.text.reconciler.IReconcilerExtension;
	21	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	22
	23	public class CompositeReconciler implements IReconciler, IReconcilerExtension {
	24	private List<IReconciler> fReconcilers;
	25
	26	public CompositeReconciler(List<IReconciler> reconcilers) {
	27	fReconcilers = reconcilers.stream().filter(Objects::nonNull).collect(Collectors.toList());
	28	}
	29
	30	@Override
	31	public String getDocumentPartitioning() {
	32	boolean defaultFound = false;
	33	String[] types = (String[]) fReconcilers.stream()
	34	.filter(IReconcilerExtension.class::isInstance)
	35	.map(IReconcilerExtension.class::cast)
	36	.map(IReconcilerExtension::getDocumentPartitioning)
	37	.filter(Objects::nonNull)
	38	.toArray();
	39	for (String type : types) {
	40	if (type.equals(IDocumentExtension3.DEFAULT_PARTITIONING)) {
	41	defaultFound = true;
	42	} else {
	43	return type;
	44	}
	45	}
	46	return defaultFound ? IDocumentExtension3.DEFAULT_PARTITIONING : null;
	47	}
	48
	49	@Override
	50	public void install(ITextViewer textViewer) {
	51	for (IReconciler iReconciler : fReconcilers) {
	52	iReconciler.install(textViewer);
	53	}
	54	}
	55
	56	@Override
	57	public void uninstall() {
	58	for (IReconciler iReconciler : fReconcilers) {
	59	iReconciler.uninstall();
	60	}
	61	}
	62
	63	@Override
	64	public IReconcilingStrategy getReconcilingStrategy(String contentType) {
	65	List<IReconcilingStrategy> strategies = new ArrayList<>();
	66	for (IReconciler iReconciler : fReconcilers) {
	67	IReconcilingStrategy strategy = iReconciler.getReconcilingStrategy(contentType);
	68	if(strategy != null) {
	69	strategies.add(strategy);
	70	}
	71	}
	72
	73	if(strategies.size() == 1) {
	74	return strategies.get(0);
	75	}
	76
	77	return new CompositeReconcilerStrategy(strategies);
	78
	79	}
	80	}

+67

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/CompositeReconcilerStrategy.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import java.util.List;
	13
	14	import org.eclipse.core.runtime.IProgressMonitor;
	15	import org.eclipse.jface.text.IDocument;
	16	import org.eclipse.jface.text.IRegion;
	17	import org.eclipse.jface.text.reconciler.DirtyRegion;
	18	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	19	import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
	20
	21	public class CompositeReconcilerStrategy implements IReconcilingStrategy, IReconcilingStrategyExtension{
	22	private List<IReconcilingStrategy> fReconcilingStrategies;
	23
	24	public CompositeReconcilerStrategy(List<IReconcilingStrategy> strategies) {
	25	this.fReconcilingStrategies = strategies;
	26	}
	27	@Override
	28	public void setProgressMonitor(IProgressMonitor monitor) {
	29	for (IReconcilingStrategy iReconcilingStrategy : fReconcilingStrategies) {
	30	if (iReconcilingStrategy instanceof IReconcilingStrategyExtension) {
	31	((IReconcilingStrategyExtension) iReconcilingStrategy).setProgressMonitor(monitor);
	32	}
	33	}
	34	}
	35
	36	@Override
	37	public void initialReconcile() {
	38	for (IReconcilingStrategy iReconcilingStrategy : fReconcilingStrategies) {
	39	if (iReconcilingStrategy instanceof IReconcilingStrategyExtension) {
	40	((IReconcilingStrategyExtension) iReconcilingStrategy).initialReconcile();
	41	}
	42	}
	43	}
	44
	45	@Override
	46	public void setDocument(IDocument document) {
	47	for (IReconcilingStrategy iReconcilingStrategy : fReconcilingStrategies) {
	48	iReconcilingStrategy.setDocument(document);
	49	}
	50	}
	51
	52	@Override
	53	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	54	for (IReconcilingStrategy iReconcilingStrategy : fReconcilingStrategies) {
	55	iReconcilingStrategy.reconcile(dirtyRegion, subRegion);
	56	}
	57	}
	58
	59	@Override
	60	public void reconcile(IRegion partition) {
	61	for (IReconcilingStrategy iReconcilingStrategy : fReconcilingStrategies) {
	62	iReconcilingStrategy.reconcile(partition);
	63	}
	64	}
	65
	66	}

+0

-94

~~org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/CompositeTextHover.java~~ less more

0		/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others.
2		* All rights reserved. This program and the accompanying materials
3		* are made available under the terms of the Eclipse Public License v1.0
4		* which accompanies this distribution, and is available at
5		* http://www.eclipse.org/legal/epl-v10.html
6		*
7		* Contributors:
8		* - Mickael Istria (Red Hat Inc.)
9		*******************************************************************************/
10		package org.eclipse.ui.internal.genericeditor;
11
12		import java.util.List;
13
14		import org.eclipse.core.runtime.Assert;
15		import org.eclipse.jface.text.IInformationControlCreator;
16		import org.eclipse.jface.text.IRegion;
17		import org.eclipse.jface.text.ITextHover;
18		import org.eclipse.jface.text.ITextHoverExtension;
19		import org.eclipse.jface.text.ITextHoverExtension2;
20		import org.eclipse.jface.text.ITextViewer;
21		import org.eclipse.ui.internal.genericeditor.TextHoverRegistry.TextHoverExtension;
22
23		/**
24		* A text hover that delegates its operations to children
25		* provided in constructor and returns the first interesting result.
26		*
27		* @since 1.0
28		*/
29		public class CompositeTextHover implements ITextHover, ITextHoverExtension, ITextHoverExtension2 {
30
31		private List<TextHoverExtension> hoversToConsider;
32		private TextHoverExtension currentHover = null;
33
34		public CompositeTextHover(List<TextHoverExtension> hoversToConsider) {
35		Assert.isNotNull(hoversToConsider);
36		this.hoversToConsider = hoversToConsider;
37		}
38
39		@Override
40		public Object getHoverInfo2(ITextViewer textViewer, IRegion hoverRegion) {
41		for (TextHoverExtension hover : this.hoversToConsider) {
42		ITextHover delegate = hover.getDelegate();
43		Object res = null;
44		if (delegate instanceof ITextHoverExtension2) {
45		res = ((ITextHoverExtension2)delegate).getHoverInfo2(textViewer, hoverRegion);
46		} else {
47		res = delegate.getHoverInfo(textViewer, hoverRegion);
48		}
49		if (res != null) {
50		currentHover = hover;
51		return res;
52		}
53		}
54		return null;
55		}
56
57		@Override
58		public IInformationControlCreator getHoverControlCreator() {
59		if (this.currentHover != null) {
60		ITextHover hover = this.currentHover.getDelegate();
61		if (hover instanceof ITextHoverExtension) {
62		return ((ITextHoverExtension)hover).getHoverControlCreator();
63		}
64		}
65		return null;
66		}
67
68		@Override
69		public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {
70		for (TextHoverExtension hover : this.hoversToConsider) {
71		ITextHover delegate = hover.getDelegate();
72		String res = delegate.getHoverInfo(textViewer, hoverRegion);
73		if (res != null) {
74		currentHover = hover;
75		return res;
76		}
77		}
78		return null;
79		}
80
81		@Override
82		public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
83		for (TextHoverExtension hover : this.hoversToConsider) {
84		ITextHover delegate = hover.getDelegate();
85		IRegion res = delegate.getHoverRegion(textViewer, offset);
86		if (res != null) {
87		return res;
88		}
89		}
90		return null;
91		}
92
93		}

+24

-47

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/ContentAssistProcessorRegistry.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others.
	1	* Copyright (c) 2016-2017 Red Hat Inc. and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

9	9	*******************************************************************************/
10	10	package org.eclipse.ui.internal.genericeditor;
11	11
12		import java.util.ArrayList;
13	12	import java.util.HashMap;
14	13	import java.util.HashSet;
15	14	import java.util.List;
16	15	import java.util.Map;
17	16	import java.util.Set;
	17	import java.util.stream.Collectors;
18	18
19	19	import org.eclipse.core.filebuffers.FileBuffers;
20		import org.eclipse.core.runtime.CoreException;
21	20	import org.eclipse.core.runtime.IConfigurationElement;
22	21	import org.eclipse.core.runtime.IPath;
23	22	import org.eclipse.core.runtime.IRegistryChangeEvent;

34	33	import org.eclipse.jface.text.contentassist.IContextInformationValidator;
35	34	import org.eclipse.jface.text.source.ISourceViewer;
36	35	import org.eclipse.ui.PlatformUI;
	36	import org.eclipse.ui.texteditor.ITextEditor;
37	37
38	38	/**
39	39	* A registry of content assist processors provided by extension <code>org.eclipse.ui.genericeditor.contentAssistProcessors</code>.

44	44	public class ContentAssistProcessorRegistry {
45	45
46	46	private static final String EXTENSION_POINT_ID = GenericEditorPlugin.BUNDLE_ID + ".contentAssistProcessors"; //$NON-NLS-1$
47
48		/**
49		* This class wraps and proxies an {@link IContentAssistProcessor} provided through extensions
50		* and loads it lazily when it can contribute to the editor, then delegates all operations to
51		* actual processor.
52		* When the contribution cannot contribute to the editor, this wrapper will return neutral values
53		* that don't affect editor behavior.
54		*/
55		private static class ContentAssistProcessorExtension implements IContentAssistProcessor {
56		private static final String CONTENT_TYPE_ATTRIBUTE = "contentType"; //$NON-NLS-1$
57		private static final String CLASS_ATTRIBUTE = "class"; //$NON-NLS-1$
58	47
59		private IConfigurationElement extension;
	48	static class ContentAssistProcessorDelegate implements IContentAssistProcessor {
	49	private final IContentAssistProcessor delegate;
60	50	private IContentType targetContentType;
61	51
62		private IContentAssistProcessor delegate;
63
64		private ContentAssistProcessorExtension(IConfigurationElement element) throws Exception {
65		this.extension = element;
66		this.targetContentType = Platform.getContentTypeManager().getContentType(element.getAttribute(CONTENT_TYPE_ATTRIBUTE));
67		}
68
69		private IContentAssistProcessor getDelegate() {
70		if (this.delegate == null) {
71		try {
72		this.delegate = (IContentAssistProcessor) extension.createExecutableExtension(CLASS_ATTRIBUTE);
73		} catch (CoreException e) {
74		e.printStackTrace();
75		}
76		}
77		return delegate;
	52	public ContentAssistProcessorDelegate(IContentAssistProcessor delegate, IContentType targetContentType) {
	53	this.delegate = delegate;
	54	this.targetContentType = targetContentType;
78	55	}
79	56
80	57	/**

103	80	@Override
104	81	public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
105	82	if (isActive(viewer)) {
106		return getDelegate().computeCompletionProposals(viewer, offset);
	83	return delegate.computeCompletionProposals(viewer, offset);
107	84	}
108	85	return new ICompletionProposal[0];
109	86	}

111	88	@Override
112	89	public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) {
113	90	if (isActive(viewer)) {
114		return getDelegate().computeContextInformation(viewer, offset);
	91	return delegate.computeContextInformation(viewer, offset);
115	92	}
116	93	return new IContextInformation[0];
117	94	}

119	96	@Override
120	97	public char[] getCompletionProposalAutoActivationCharacters() {
121	98	if (isActive(null)) {
122		return getDelegate().getCompletionProposalAutoActivationCharacters();
	99	return delegate.getCompletionProposalAutoActivationCharacters();
123	100	}
124	101	return null;
125	102	}

127	104	@Override
128	105	public char[] getContextInformationAutoActivationCharacters() {
129	106	if (isActive(null)) {
130		return getDelegate().getContextInformationAutoActivationCharacters();
	107	return delegate.getContextInformationAutoActivationCharacters();
131	108	}
132	109	return null;
133	110	}

135	112	@Override
136	113	public String getErrorMessage() {
137	114	if (isActive(null)) {
138		return getDelegate().getErrorMessage();
	115	return delegate.getErrorMessage();
139	116	}
140	117	return null;
141	118	}

143	120	@Override
144	121	public IContextInformationValidator getContextInformationValidator() {
145	122	if (isActive(null)) {
146		return getDelegate().getContextInformationValidator();
	123	return delegate.getContextInformationValidator();
147	124	}
148	125	return null;
149	126	}
150	127	}
151	128
152		private Map<IConfigurationElement, ContentAssistProcessorExtension> extensions = new HashMap<>();
	129	private Map<IConfigurationElement, GenericContentTypeRelatedExtension<IContentAssistProcessor>> extensions = new HashMap<>();
153	130	private boolean outOfSync = true;
154	131
155	132	/**

168	145	* Get the contributed {@link IContentAssistProcessor}s that are relevant to hook on source viewer according
169	146	* to document content types.
170	147	* @param sourceViewer the source viewer we're hooking completion to.
	148	* @param editor the text editor
171	149	* @param contentTypes the content types of the document we're editing.
172	150	* @return the list of {@link IContentAssistProcessor} contributed for at least one of the content types.
173	151	*/
174		public List<IContentAssistProcessor> getContentAssistProcessors(ISourceViewer sourceViewer, Set<IContentType> contentTypes) {
	152	public List<IContentAssistProcessor> getContentAssistProcessors(ISourceViewer sourceViewer, ITextEditor editor, Set<IContentType> contentTypes) {
175	153	if (this.outOfSync) {
176	154	sync();
177	155	}
178		List<IContentAssistProcessor> res = new ArrayList<>();
179		for (ContentAssistProcessorExtension ext : this.extensions.values()) {
180		if (contentTypes.contains(ext.targetContentType)) {
181		res.add(ext);
182		}
183		}
184		return res;
	156	return this.extensions.values().stream()
	157	.filter(ext -> contentTypes.contains(ext.targetContentType))
	158	.filter(ext -> ext.matches(sourceViewer, editor))
	159	.sorted(new ContentTypeSpecializationComparator<IContentAssistProcessor>())
	160	.map(GenericContentTypeRelatedExtension<IContentAssistProcessor>::createDelegate)
	161	.collect(Collectors.toList());
185	162	}
186	163
187	164	private void sync() {

190	167	toRemoveExtensions.remove(extension);
191	168	if (!this.extensions.containsKey(extension)) {
192	169	try {
193		this.extensions.put(extension, new ContentAssistProcessorExtension(extension));
	170	this.extensions.put(extension, new GenericContentTypeRelatedExtension<IContentAssistProcessor>(extension));
194	171	} catch (Exception ex) {
195	172	GenericEditorPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID, ex.getMessage(), ex));
196	173	}

+39

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/ContentTypeSpecializationComparator.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Mickael Istria (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import java.util.Comparator;
	13
	14	import org.eclipse.core.runtime.content.IContentType;
	15
	16	/**
	17	* Compares extension so that the ones with the most "specialized" content-types are returned first.
	18	*
	19	* @param <T>
	20	*/
	21	public class ContentTypeSpecializationComparator<T> implements Comparator<GenericContentTypeRelatedExtension<T>> {
	22
	23	@Override
	24	public int compare(GenericContentTypeRelatedExtension<T> o1, GenericContentTypeRelatedExtension<T> o2) {
	25	return depth(o2.targetContentType) - depth(o1.targetContentType);
	26	}
	27
	28	private static int depth(IContentType targetContentType) {
	29	int res = 0;
	30	IContentType current = targetContentType;
	31	while (current != null) {
	32	res++;
	33	current = current.getBaseType();
	34	}
	35	return res;
	36	}
	37
	38	}

+1

-1

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/DefaultContentAssistProcessor.java less more

73	73	return proposals.toArray(new ICompletionProposal[proposals.size()]);
74	74	}
75	75
76		private int findStartingPoint(String text, int offset) {
	76	private static int findStartingPoint(String text, int offset) {
77	77	String substring = text.substring(0, offset);
78	78	Matcher m = NON_ALPHANUMERIC_LAST_PATTERN.matcher(substring);
79	79	m.find();

+37

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/DefaultWordHighlightReconciler.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Lucas Bullen (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import org.eclipse.jface.text.IDocument;
	13	import org.eclipse.jface.text.ITextViewer;
	14	import org.eclipse.jface.text.reconciler.Reconciler;
	15
	16	public class DefaultWordHighlightReconciler extends Reconciler {
	17
	18	private DefaultWordHighlightStrategy fStrategy;
	19
	20	public DefaultWordHighlightReconciler() {
	21	fStrategy = new DefaultWordHighlightStrategy();
	22	this.setReconcilingStrategy(fStrategy, IDocument.DEFAULT_CONTENT_TYPE);
	23	}
	24
	25	@Override
	26	public void install(ITextViewer textViewer) {
	27	super.install(textViewer);
	28	fStrategy.install(textViewer);
	29	}
	30
	31	@Override
	32	public void uninstall() {
	33	super.uninstall();
	34	fStrategy.uninstall();
	35	}
	36	}⏎

+232

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/DefaultWordHighlightStrategy.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017, 2018 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Lucas Bullen (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import java.util.HashMap;
	13	import java.util.Iterator;
	14	import java.util.Map;
	15	import java.util.Map.Entry;
	16	import java.util.regex.Matcher;
	17	import java.util.regex.Pattern;
	18
	19	import org.eclipse.core.runtime.IProgressMonitor;
	20	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
	21	import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
	22	import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;
	23	import org.eclipse.core.runtime.preferences.InstanceScope;
	24	import org.eclipse.jface.text.IDocument;
	25	import org.eclipse.jface.text.IRegion;
	26	import org.eclipse.jface.text.ISynchronizable;
	27	import org.eclipse.jface.text.ITextViewer;
	28	import org.eclipse.jface.text.ITextViewerExtension5;
	29	import org.eclipse.jface.text.Position;
	30	import org.eclipse.jface.text.reconciler.DirtyRegion;
	31	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	32	import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
	33	import org.eclipse.jface.text.source.Annotation;
	34	import org.eclipse.jface.text.source.IAnnotationModel;
	35	import org.eclipse.jface.text.source.IAnnotationModelExtension;
	36	import org.eclipse.jface.text.source.ISourceViewer;
	37	import org.eclipse.osgi.util.NLS;
	38	import org.eclipse.swt.custom.CaretEvent;
	39	import org.eclipse.swt.custom.CaretListener;
	40
	41	/**
	42	*
	43	* This Reconciler Strategy is a default stategy which will be present if no
	44	* other highlightReconcilers are registered for a given content-type. It splits
	45	* the text into 'words' (which are defined as anything in-between
	46	* non-alphanumeric characters) and searches the document highlighting all like
	47	* words.
	48	*
	49	* E.g. if your file contains "t^he dog in the bog" and you leave your caret at
	50	* ^ you will get both instances of 'the' highlighted.
	51	*
	52	*/
	53	public class DefaultWordHighlightStrategy
	54	implements IReconcilingStrategy, IReconcilingStrategyExtension, CaretListener, IPreferenceChangeListener {
	55
	56	private static final String ANNOTATION_TYPE = "org.eclipse.ui.genericeditor.text"; //$NON-NLS-1$
	57
	58	private boolean enabled;
	59	private ISourceViewer sourceViewer;
	60	private IDocument document;
	61
	62	private static final String WORD_REGEXP = "\\w+"; //$NON-NLS-1$
	63	private static final Pattern WORD_PATTERN = Pattern.compile(WORD_REGEXP, Pattern.UNICODE_CHARACTER_CLASS);
	64	private static final Pattern CURRENT_WORD_START_PATTERN = Pattern.compile(WORD_REGEXP + "$", //$NON-NLS-1$
	65	Pattern.UNICODE_CHARACTER_CLASS);
	66
	67	private Annotation[] fOccurrenceAnnotations = null;
	68
	69	private void applyHighlights(int offset) {
	70	if (sourceViewer == null \|\| !enabled) {
	71	removeOccurrenceAnnotations();
	72	return;
	73	}
	74
	75	String text = document.get();
	76	offset = ((ITextViewerExtension5) sourceViewer).widgetOffset2ModelOffset(offset);
	77
	78	String word = findCurrentWord(text, offset);
	79	if (word == null) {
	80	removeOccurrenceAnnotations();
	81	return;
	82	}
	83
	84	Matcher m = WORD_PATTERN.matcher(text);
	85	Map<Annotation, Position> annotationMap = new HashMap<>();
	86	while (m.find()) {
	87	if (m.group().equals(word)) {
	88	annotationMap.put(
	89	new Annotation(ANNOTATION_TYPE, false,
	90	NLS.bind(Messages.DefaultWordHighlightStrategy_OccurrencesOf, word)),
	91	new Position(m.start(), m.end() - m.start()));
	92	}
	93	}
	94
	95	if (annotationMap.size() < 2) {
	96	removeOccurrenceAnnotations();
	97	return;
	98	}
	99
	100	IAnnotationModel annotationModel = sourceViewer.getAnnotationModel();
	101	synchronized (getLockObject(annotationModel)) {
	102	if (annotationModel instanceof IAnnotationModelExtension) {
	103	((IAnnotationModelExtension) annotationModel).replaceAnnotations(fOccurrenceAnnotations, annotationMap);
	104	} else {
	105	removeOccurrenceAnnotations();
	106	Iterator<Entry<Annotation, Position>> iter = annotationMap.entrySet().iterator();
	107	while (iter.hasNext()) {
	108	Entry<Annotation, Position> mapEntry = iter.next();
	109	annotationModel.addAnnotation(mapEntry.getKey(), mapEntry.getValue());
	110	}
	111	}
	112	fOccurrenceAnnotations = annotationMap.keySet().toArray(new Annotation[annotationMap.keySet().size()]);
	113	}
	114	}
	115
	116	private static String findCurrentWord(String text, int offset) {
	117	String wordStart = null;
	118	String wordEnd = null;
	119
	120	String substring = text.substring(0, offset);
	121	Matcher m = CURRENT_WORD_START_PATTERN.matcher(substring);
	122	if (m.find()) {
	123	wordStart = m.group();
	124	}
	125	substring = text.substring(offset);
	126	m = WORD_PATTERN.matcher(substring);
	127	if (m.lookingAt()) {
	128	wordEnd = m.group();
	129	}
	130	if (wordStart != null && wordEnd != null)
	131	return wordStart + wordEnd;
	132	if (wordStart != null)
	133	return wordStart;
	134	return wordEnd;
	135	}
	136
	137	public void install(ITextViewer viewer) {
	138	if (!(viewer instanceof ISourceViewer)) {
	139	return;
	140	}
	141	IEclipsePreferences preferences = InstanceScope.INSTANCE.getNode(GenericEditorPlugin.BUNDLE_ID);
	142	preferences.addPreferenceChangeListener(this);
	143	this.enabled = preferences.getBoolean(ToggleHighlight.TOGGLE_HIGHLIGHT_PREFERENCE, true);
	144	this.sourceViewer = (ISourceViewer) viewer;
	145	this.sourceViewer.getTextWidget().addCaretListener(this);
	146	}
	147
	148	public void uninstall() {
	149	if (sourceViewer != null) {
	150	sourceViewer.getTextWidget().removeCaretListener(this);
	151	}
	152	IEclipsePreferences preferences = InstanceScope.INSTANCE.getNode(GenericEditorPlugin.BUNDLE_ID);
	153	preferences.removePreferenceChangeListener(this);
	154	}
	155
	156	@Override
	157	public void preferenceChange(PreferenceChangeEvent event) {
	158	if (event.getKey().equals(ToggleHighlight.TOGGLE_HIGHLIGHT_PREFERENCE)) {
	159	this.enabled = Boolean.parseBoolean(event.getNewValue().toString());
	160	if (enabled) {
	161	initialReconcile();
	162	} else {
	163	removeOccurrenceAnnotations();
	164	}
	165	}
	166	}
	167
	168	@Override
	169	public void caretMoved(CaretEvent event) {
	170	applyHighlights(event.caretOffset);
	171	}
	172
	173	@Override
	174	public void initialReconcile() {
	175	if (sourceViewer != null) {
	176	sourceViewer.getTextWidget().getDisplay().asyncExec(() -> {
	177	if (sourceViewer != null && sourceViewer.getTextWidget() != null) {
	178	applyHighlights(sourceViewer.getTextWidget().getCaretOffset());
	179	}
	180	});
	181	}
	182	}
	183
	184	void removeOccurrenceAnnotations() {
	185	IAnnotationModel annotationModel = sourceViewer.getAnnotationModel();
	186	if (annotationModel == null \|\| fOccurrenceAnnotations == null) {
	187	return;
	188	}
	189
	190	synchronized (getLockObject(annotationModel)) {
	191	if (annotationModel instanceof IAnnotationModelExtension) {
	192	((IAnnotationModelExtension) annotationModel).replaceAnnotations(fOccurrenceAnnotations, null);
	193	} else {
	194	for (Annotation fOccurrenceAnnotation : fOccurrenceAnnotations) {
	195	annotationModel.removeAnnotation(fOccurrenceAnnotation);
	196	}
	197	}
	198	fOccurrenceAnnotations = null;
	199	}
	200	}
	201
	202	private static Object getLockObject(IAnnotationModel annotationModel) {
	203	if (annotationModel instanceof ISynchronizable) {
	204	Object lock = ((ISynchronizable) annotationModel).getLockObject();
	205	if (lock != null) {
	206	return lock;
	207	}
	208	}
	209	return annotationModel;
	210	}
	211
	212	@Override
	213	public void setDocument(IDocument document) {
	214	this.document = document;
	215	}
	216
	217	@Override
	218	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	219	// Do nothing
	220	}
	221
	222	@Override
	223	public void reconcile(IRegion partition) {
	224	// Do nothing
	225	}
	226
	227	@Override
	228	public void setProgressMonitor(IProgressMonitor monitor) {
	229	// Not used
	230	}
	231	}

+30

-3

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/ExtensionBasedTextEditor.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2016 Red Hat Inc. and others.
	1	* Copyright (c) 2000, 2017 Red Hat Inc. and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

6	6	*
7	7	* Contributors:
8	8	* Sopot Cela, Mickael Istria (Red Hat Inc.) - initial implementation
	9	* Lucas Bullen (Red Hat Inc.) - Bug 508829 custom reconciler support
9	10	*******************************************************************************/
10	11	package org.eclipse.ui.internal.genericeditor;
11	12
12	13	import org.eclipse.core.runtime.CoreException;
	14	import org.eclipse.jface.text.source.ISourceViewer;
	15	import org.eclipse.jface.text.source.IVerticalRuler;
	16	import org.eclipse.jface.text.source.projection.ProjectionSupport;
	17	import org.eclipse.jface.text.source.projection.ProjectionViewer;
	18	import org.eclipse.swt.widgets.Composite;
13	19	import org.eclipse.ui.IEditorInput;
14	20	import org.eclipse.ui.editors.text.TextEditor;
15	21
16	22	/**
17	23	* A generic code editor that is aimed at being extended by contributions. Behavior
18	24	* is supposed to be added via extensions, not by inheritance.
19		*
	25	*
20	26	* @since 1.0
21	27	*/
22	28	public class ExtensionBasedTextEditor extends TextEditor {

31	37	configuration = new ExtensionBasedTextViewerConfiguration(this, getPreferenceStore());
32	38	setSourceViewerConfiguration(configuration);
33	39	}
34
	40
35	41	@Override
36	42	protected void setKeyBindingScopes(String[] scopes) {
37	43	super.setKeyBindingScopes(new String[] { CONTEXT_ID });

43	49	configuration.watchDocument(getDocumentProvider().getDocument(input));
44	50	}
45	51
	52	@Override
	53	protected ISourceViewer createSourceViewer(Composite parent, IVerticalRuler ruler, int styles) {
	54	fAnnotationAccess= getAnnotationAccess();
	55	fOverviewRuler= createOverviewRuler(getSharedColors());
	56
	57	ProjectionViewer viewer= new ProjectionViewer(parent, ruler, getOverviewRuler(), isOverviewRulerVisible(), styles);
	58	getSourceViewerDecorationSupport(viewer);
	59	return viewer;
	60	}
	61
	62
	63	@Override
	64	public void createPartControl(Composite parent)
	65	{
	66	super.createPartControl(parent);
	67	ProjectionViewer viewer =(ProjectionViewer)getSourceViewer();
	68
	69	new ProjectionSupport(viewer,getAnnotationAccess(),getSharedColors()).install();
	70	viewer.doOperation(ProjectionViewer.TOGGLE);
	71	}
	72
46	73	}

+45

-20

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/ExtensionBasedTextViewerConfiguration.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others.
	1	* Copyright (c) 2016, 2017 Red Hat Inc. and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

6	6	*
7	7	* Contributors:
8	8	* Sopot Cela, Mickael Istria (Red Hat Inc.) - initial implementation
	9	* Lucas Bullen (Red Hat Inc.) - Bug 508829 custom reconciler support
	10	* - Bug 521382 default highlight reconciler
	11	* Simon Scholz <simon.scholz@vogella.com> - Bug 527830
9	12	*******************************************************************************/
10	13	package org.eclipse.ui.internal.genericeditor;
11	14

23	26	import org.eclipse.jface.preference.IPreferenceStore;
24	27	import org.eclipse.jface.text.AbstractReusableInformationControlCreator;
25	28	import org.eclipse.jface.text.DefaultInformationControl;
	29	import org.eclipse.jface.text.IAutoEditStrategy;
26	30	import org.eclipse.jface.text.IDocument;
27	31	import org.eclipse.jface.text.IDocumentPartitioningListener;
28	32	import org.eclipse.jface.text.IInformationControl;
29		import org.eclipse.jface.text.IInformationControlCreator;
30	33	import org.eclipse.jface.text.ITextHover;
31	34	import org.eclipse.jface.text.contentassist.ContentAssistant;
32	35	import org.eclipse.jface.text.contentassist.IContentAssistProcessor;

38	41	import org.eclipse.jface.text.source.ISourceViewer;
39	42	import org.eclipse.swt.widgets.Shell;
40	43	import org.eclipse.ui.IEditorPart;
41		import org.eclipse.ui.IPropertyListener;
42	44	import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;
43	45	import org.eclipse.ui.internal.editors.text.EditorsPlugin;
	46	import org.eclipse.ui.internal.genericeditor.hover.CompositeTextHover;
44	47	import org.eclipse.ui.internal.genericeditor.markers.MarkerResoltionQuickAssistProcessor;
45	48	import org.eclipse.ui.texteditor.ITextEditor;
46	49	import org.eclipse.ui.texteditor.spelling.SpellingCorrectionProcessor;

70	73	public ExtensionBasedTextViewerConfiguration(ITextEditor editor, IPreferenceStore preferenceStore) {
71	74	super(preferenceStore);
72	75	this.editor = editor;
73		this.editor.addPropertyListener(new IPropertyListener() {
74		@Override
75		public void propertyChanged(Object source, int propId) {
76		if (propId == IEditorPart.PROP_INPUT) {
77		watchDocument(editor.getDocumentProvider().getDocument(editor.getEditorInput()));
78		}
	76	this.editor.addPropertyListener((source, propId) -> {
	77	if (propId == IEditorPart.PROP_INPUT) {
	78	watchDocument(editor.getDocumentProvider().getDocument(editor.getEditorInput()));
79	79	}
80	80	});
81	81	}

98	98
99	99	@Override
100	100	public ITextHover getTextHover(ISourceViewer sourceViewer, String contentType) {
101		TextHoverRegistry registry= GenericEditorPlugin.getDefault().getHoverRegistry();
102		return registry.getAvailableHover(sourceViewer, getContentTypes());
	101	List<ITextHover> hovers = GenericEditorPlugin.getDefault().getHoverRegistry().getAvailableHovers(sourceViewer, editor, getContentTypes());
	102	if (hovers == null \|\| hovers.isEmpty()) {
	103	return null;
	104	} else if (hovers.size() == 1) {
	105	return hovers.get(0);
	106	} else {
	107	return new CompositeTextHover(hovers);
	108	}
103	109	}
104	110
105	111	@Override

108	114	contentAssistant= new ContentAssistant(true);
109	115	contentAssistant.setContextInformationPopupOrientation(ContentAssistant.CONTEXT_INFO_BELOW);
110	116	contentAssistant.setProposalPopupOrientation(ContentAssistant.PROPOSAL_REMOVE);
	117	contentAssistant.setAutoActivationDelay(0);
111	118	contentAssistant.enableColoredLabels(true);
112	119	contentAssistant.enableAutoActivation(true);
113		this.processors = registry.getContentAssistProcessors(sourceViewer, getContentTypes());
	120	this.processors = registry.getContentAssistProcessors(sourceViewer, editor, getContentTypes());
114	121	if (this.processors.isEmpty()) {
115	122	this.processors.add(new DefaultContentAssistProcessor());
116	123	}

132	139	@Override
133	140	public IPresentationReconciler getPresentationReconciler(ISourceViewer sourceViewer) {
134	141	PresentationReconcilerRegistry registry = GenericEditorPlugin.getDefault().getPresentationReconcilerRegistry();
135		List<IPresentationReconciler> reconciliers = registry.getPresentationReconcilers(sourceViewer, getContentTypes());
	142	List<IPresentationReconciler> reconciliers = registry.getPresentationReconcilers(sourceViewer, editor, getContentTypes());
136	143	if (!reconciliers.isEmpty()) {
137	144	return reconciliers.get(0);
138	145	}

176	183	));
177	184	quickAssistAssistant.setQuickAssistProcessor(processor);
178	185	quickAssistAssistant.setRestoreCompletionProposalSize(EditorsPlugin.getDefault().getDialogSettingsSection("quick_assist_proposal_size")); //$NON-NLS-1$
179		quickAssistAssistant.setInformationControlCreator(new IInformationControlCreator() {
180		@Override
181		public IInformationControl createInformationControl(Shell parent) {
182		return new DefaultInformationControl(parent, EditorsPlugin.getAdditionalInfoAffordanceString());
183		}
184		});
	186	quickAssistAssistant.setInformationControlCreator(parent -> new DefaultInformationControl(parent, EditorsPlugin.getAdditionalInfoAffordanceString()));
185	187	return quickAssistAssistant;
186	188	}
187	189
188	190	@Override
189	191	public IReconciler getReconciler(ISourceViewer sourceViewer) {
190		return null; // to disable spell-checker
	192	ReconcilerRegistry registry = GenericEditorPlugin.getDefault().getReconcilerRegistry();
	193	List<IReconciler> reconciliers = registry.getReconcilers(sourceViewer, editor, getContentTypes());
	194	List<IReconciler> highlightReconciliers = registry.getHighlightReconcilers(sourceViewer, editor, getContentTypes());
	195
	196	if(!highlightReconciliers.isEmpty()) {
	197	reconciliers.addAll(highlightReconciliers);
	198	}else {
	199	reconciliers.add(new DefaultWordHighlightReconciler());
	200	}
	201
	202	if (!reconciliers.isEmpty()) {
	203	return new CompositeReconciler(reconciliers);
	204	}
	205	return null;
	206	}
	207
	208	@Override
	209	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {
	210	AutoEditStrategyRegistry registry = GenericEditorPlugin.getDefault().getAutoEditStrategyRegistry();
	211	List<IAutoEditStrategy> editStrategies = registry.getAutoEditStrategies(sourceViewer, editor, getContentTypes());
	212	if (!editStrategies.isEmpty()) {
	213	return editStrategies.toArray(new IAutoEditStrategy[editStrategies.size()]);
	214	}
	215	return super.getAutoEditStrategies(sourceViewer, contentType);
191	216	}
192	217
193	218	@Override

+112

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/GenericContentTypeRelatedExtension.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Mickael Istria (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import org.eclipse.core.expressions.ElementHandler;
	13	import org.eclipse.core.expressions.EvaluationContext;
	14	import org.eclipse.core.expressions.EvaluationResult;
	15	import org.eclipse.core.expressions.Expression;
	16	import org.eclipse.core.expressions.ExpressionConverter;
	17	import org.eclipse.core.runtime.CoreException;
	18	import org.eclipse.core.runtime.IConfigurationElement;
	19	import org.eclipse.core.runtime.IStatus;
	20	import org.eclipse.core.runtime.Platform;
	21	import org.eclipse.core.runtime.Status;
	22	import org.eclipse.core.runtime.content.IContentType;
	23	import org.eclipse.jface.text.source.ISourceViewer;
	24	import org.eclipse.ui.texteditor.ITextEditor;
	25
	26	/**
	27	* This class wraps and proxies an instance of T provided through extensions
	28	* and loads it lazily when it can contribute to the editor, then delegates all operations to
	29	* actual instance.
	30	*
	31	* @param <T> the actual type to proxy, typically the one defined on the extension point.
	32	*/
	33	public class GenericContentTypeRelatedExtension<T> {
	34	private static final String ID_ATTRIBUTE = "id"; //$NON-NLS-1$
	35	private static final String CLASS_ATTRIBUTE = "class"; //$NON-NLS-1$
	36	private static final String CONTENT_TYPE_ATTRIBUTE = "contentType"; //$NON-NLS-1$
	37	private static final String ENABLED_WHEN_ATTRIBUTE = "enabledWhen"; //$NON-NLS-1$
	38
	39	public final IConfigurationElement extension;
	40	public final IContentType targetContentType;
	41	public final Expression enabledWhen;
	42
	43	public GenericContentTypeRelatedExtension(IConfigurationElement element) throws Exception {
	44	this.extension = element;
	45	this.targetContentType = Platform.getContentTypeManager()
	46	.getContentType(element.getAttribute(CONTENT_TYPE_ATTRIBUTE));
	47	this.enabledWhen = buildEnabledWhen(element);
	48	}
	49
	50	@SuppressWarnings("unchecked")
	51	public T createDelegate() {
	52	try {
	53	return (T) extension.createExecutableExtension(CLASS_ATTRIBUTE);
	54	} catch (CoreException e) {
	55	GenericEditorPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID, e.getMessage(), e));
	56	}
	57	return null;
	58	}
	59
	60	/**
	61	* Returns the expression {@link Expression} declared in the
	62	* <code>enabledWhen</code> element.
	63	*
	64	* @param configElement the configuration element
	65	* @return the expression {@link Expression} declared in the enabledWhen
	66	* element.
	67	* @throws CoreException when enabledWhen expression is not valid.
	68	*/
	69	private static Expression buildEnabledWhen(IConfigurationElement configElement) throws CoreException {
	70	final IConfigurationElement[] children = configElement.getChildren(ENABLED_WHEN_ATTRIBUTE);
	71	if (children.length > 0) {
	72	IConfigurationElement[] subChildren = children[0].getChildren();
	73	if (subChildren.length != 1) {
	74	throw new CoreException(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID,
	75	"One <enabledWhen> element is accepted. Disabling " //$NON-NLS-1$
	76	+ configElement.getAttribute(ID_ATTRIBUTE)));
	77	}
	78	final ElementHandler elementHandler = ElementHandler.getDefault();
	79	final ExpressionConverter converter = ExpressionConverter.getDefault();
	80	return elementHandler.create(converter, subChildren[0]);
	81	}
	82	return null;
	83	}
	84
	85	/**
	86	* Returns true if the given viewer, editor matches the enabledWhen expression
	87	* and false otherwise.
	88	*
	89	* @param viewer the viewer
	90	* @param editor the editor
	91	* @return true if the given viewer, editor matches the enabledWhen expression
	92	* and false otherwise.
	93	*/
	94	public boolean matches(ISourceViewer viewer, ITextEditor editor) {
	95	if (enabledWhen == null) {
	96	return true;
	97	}
	98	EvaluationContext context = new EvaluationContext(null, editor);
	99	context.setAllowPluginActivation(true);
	100	context.addVariable("viewer", viewer); //$NON-NLS-1$
	101	context.addVariable("editor", editor); //$NON-NLS-1$
	102	context.addVariable("editorInput", editor.getEditorInput()); //$NON-NLS-1$
	103	try {
	104	return enabledWhen.evaluate(context) == EvaluationResult.TRUE;
	105	} catch (CoreException e) {
	106	GenericEditorPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID,
	107	"Error while 'enabledWhen' evaluation", e)); //$NON-NLS-1$
	108	return false;
	109	}
	110	}
	111	}

+27

-1

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/GenericEditorPlugin.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others.
	1	* Copyright (c) 2016, 2017 Red Hat Inc. and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

6	6	*
7	7	* Contributors:
8	8	* Sopot Cela, Mickael Istria (Red Hat Inc.) - initial implementation
	9	* Lucas Bullen (Red Hat Inc.) - Bug 508829 custom reconciler support
9	10	*******************************************************************************/
10	11	package org.eclipse.ui.internal.genericeditor;
11	12
12	13	import org.eclipse.jface.text.ITextHover;
13	14	import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
14	15	import org.eclipse.jface.text.presentation.IPresentationReconciler;
	16	import org.eclipse.ui.internal.genericeditor.hover.TextHoverRegistry;
15	17	import org.eclipse.ui.plugin.AbstractUIPlugin;
16	18	import org.osgi.framework.BundleContext;
17	19

28	30
29	31	private TextHoverRegistry textHoversRegistry;
30	32	private ContentAssistProcessorRegistry contentAssistProcessorsRegistry;
	33	private ReconcilerRegistry reconcilierRegistry;
31	34	private PresentationReconcilerRegistry presentationReconcilierRegistry;
	35	private AutoEditStrategyRegistry autoEditStrategyRegistry;
32	36
33	37	@Override
34	38	public void start(BundleContext context) throws Exception{

67	71	}
68	72	return this.contentAssistProcessorsRegistry;
69	73	}
	74
	75	/**
	76	* @return the registry allowing to access contributed {@link IReconciler}s.
	77	* @since 1.1
	78	*/
	79	public synchronized ReconcilerRegistry getReconcilerRegistry() {
	80	if (this.reconcilierRegistry == null) {
	81	this.reconcilierRegistry = new ReconcilerRegistry();
	82	}
	83	return this.reconcilierRegistry;
	84	}
70	85
71	86	/**
72	87	* @return the registry allowing to access contributed {@link IPresentationReconciler}s.

78	93	}
79	94	return this.presentationReconcilierRegistry;
80	95	}
	96
	97	/**
	98	* @return the registry allowing to access contributed {@link IAutoEditStrategy}s.
	99	* @since 1.1
	100	*/
	101	public synchronized AutoEditStrategyRegistry getAutoEditStrategyRegistry() {
	102	if (this.autoEditStrategyRegistry == null) {
	103	this.autoEditStrategyRegistry = new AutoEditStrategyRegistry();
	104	}
	105	return this.autoEditStrategyRegistry;
	106	}
81	107	}

+25

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/Messages.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2018 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Alexander Kurtakov (Red Hat Inc.) - initial version
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import org.eclipse.osgi.util.NLS;
	13
	14	public class Messages extends NLS {
	15	private static final String BUNDLE_NAME = "org.eclipse.ui.internal.genericeditor.messages"; //$NON-NLS-1$
	16	public static String DefaultWordHighlightStrategy_OccurrencesOf;
	17	static {
	18	// initialize resource bundle
	19	NLS.initializeMessages(BUNDLE_NAME, Messages.class);
	20	}
	21
	22	private Messages() {
	23	}
	24	}

+0

-91

~~org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/OrderedExtensionComparator.java~~ less more

0		/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others.
2		* All rights reserved. This program and the accompanying materials
3		* are made available under the terms of the Eclipse Public License v1.0
4		* which accompanies this distribution, and is available at
5		* http://www.eclipse.org/legal/epl-v10.html
6		*
7		* Contributors:
8		* Mickael Istria (Red Hat Inc.) - initial implementation
9		*******************************************************************************/
10		package org.eclipse.ui.internal.genericeditor;
11
12		import java.util.Collection;
13		import java.util.Comparator;
14		import java.util.Map;
15		import java.util.function.Function;
16		import java.util.stream.Collectors;
17
18		import org.eclipse.core.runtime.Assert;
19		import org.eclipse.ui.internal.genericeditor.TextHoverRegistry.TextHoverExtension;
20
21		/**
22		* A comparator that allows to sort elements according to their relative
23		* placement (isBefore and isAfter)
24		*
25		*/
26		class OrderedExtensionComparator implements Comparator<TextHoverExtension> {
27
28		private Map<String, TextHoverExtension> extensionsById;
29
30		public OrderedExtensionComparator(Collection<TextHoverExtension> extensions) {
31		Assert.isNotNull(extensions);
32		this.extensionsById = extensions.stream().collect(Collectors.toMap(TextHoverExtension::getId, Function.identity()));
33		}
34
35		@Override
36		public int compare(TextHoverExtension arg0, TextHoverExtension arg1) {
37		if (isDeclaredAsBefore(arg0, arg1) \|\| isDeclaredAsAfter(arg1, arg0)) {
38		return -1;
39		}
40		if (isDeclaredAsAfter(arg0, arg1) \|\| isDeclaredAsBefore(arg1, arg0)) {
41		return +1;
42		}
43		return arg0.toString().compareTo(arg1.toString());
44		}
45
46		private boolean isDeclaredAsBefore(TextHoverExtension arg0, TextHoverExtension arg1) {
47		String before0 = arg0.getIsBefore();
48		if (before0 == null) {
49		return false;
50		}
51		if ("".equals(before0) && !"".equals(arg1.getIsBefore())) { //$NON-NLS-1$ //$NON-NLS-2$
52		return true;
53		}
54		String id1 = arg1.getId();
55		if (id1 == null) {
56		return false;
57		}
58		if (before0.equals(id1)) {
59		return true;
60		}
61		String after1 = arg1.getIsAfter();
62		if (after1 == null) {
63		return false;
64		}
65		return isDeclaredAsAfter(arg0, this.extensionsById.get(after1));
66		}
67
68		private boolean isDeclaredAsAfter(TextHoverExtension arg0, TextHoverExtension arg1) {
69		String after0 = arg0.getIsAfter();
70		if (after0 == null) {
71		return false;
72		}
73		if ("".equals(after0) && !"".equals(arg1.getIsAfter())) { //$NON-NLS-1$ //$NON-NLS-2$
74		return true;
75		}
76		String id1 = arg1.getId();
77		if (id1 == null) {
78		return false;
79		}
80		if (after0.equals(id1)) {
81		return true;
82		}
83		String before1 = arg1.getIsBefore();
84		if (before1 == null) {
85		return false;
86		}
87		return isDeclaredAsAfter(arg0, this.extensionsById.get(before1));
88		}
89
90		}⏎

+13

-68

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/PresentationReconcilerRegistry.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others.
	1	* Copyright (c) 2016-2017 Red Hat Inc. and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

9	9	*******************************************************************************/
10	10	package org.eclipse.ui.internal.genericeditor;
11	11
12		import java.util.ArrayList;
13	12	import java.util.HashMap;
14	13	import java.util.HashSet;
15	14	import java.util.List;
16	15	import java.util.Map;
17	16	import java.util.Set;
	17	import java.util.stream.Collectors;
18	18
19		import org.eclipse.core.runtime.CoreException;
20	19	import org.eclipse.core.runtime.IConfigurationElement;
21	20	import org.eclipse.core.runtime.IRegistryChangeEvent;
22	21	import org.eclipse.core.runtime.IRegistryChangeListener;

24	23	import org.eclipse.core.runtime.Platform;
25	24	import org.eclipse.core.runtime.Status;
26	25	import org.eclipse.core.runtime.content.IContentType;
27		import org.eclipse.jface.text.ITextViewer;
28		import org.eclipse.jface.text.presentation.IPresentationDamager;
29	26	import org.eclipse.jface.text.presentation.IPresentationReconciler;
30		import org.eclipse.jface.text.presentation.IPresentationRepairer;
31	27	import org.eclipse.jface.text.source.ISourceViewer;
	28	import org.eclipse.ui.texteditor.ITextEditor;
32	29
33	30	/**
34	31	* A registry of presentation reconciliers provided by extension <code>org.eclipse.ui.genericeditor.presentationReconcilers</code>.

40	37
41	38	private static final String EXTENSION_POINT_ID = GenericEditorPlugin.BUNDLE_ID + ".presentationReconcilers"; //$NON-NLS-1$
42	39
43		/**
44		* This class wraps and proxies an {@link IPresentationReconcilier} provided through extensions
45		* and loads it lazily when it can contribute to the editor, then delegates all operations to
46		* actual reconcilier.
47		*/
48		private static class PresentationReconcilerExtension implements IPresentationReconciler {
49		private static final String CLASS_ATTRIBUTE = "class"; //$NON-NLS-1$
50		private static final String CONTENT_TYPE_ATTRIBUTE = "contentType"; //$NON-NLS-1$
51
52		private IConfigurationElement extension;
53		private IContentType targetContentType;
54
55		private IPresentationReconciler delegate;
56
57		private PresentationReconcilerExtension(IConfigurationElement element) throws Exception {
58		this.extension = element;
59		this.targetContentType = Platform.getContentTypeManager().getContentType(element.getAttribute(CONTENT_TYPE_ATTRIBUTE));
60		}
61
62		private IPresentationReconciler getDelegate() {
63		if (this.delegate == null) {
64		try {
65		this.delegate = (IPresentationReconciler) extension.createExecutableExtension(CLASS_ATTRIBUTE);
66		} catch (CoreException e) {
67		e.printStackTrace();
68		}
69		}
70		return delegate;
71		}
72
73		@Override
74		public void install(ITextViewer viewer) {
75		getDelegate().install(viewer);
76		}
77
78		@Override
79		public void uninstall() {
80		getDelegate().uninstall();
81		}
82
83		@Override
84		public IPresentationDamager getDamager(String contentType) {
85		return getDelegate().getDamager(contentType);
86
87		}
88
89		@Override
90		public IPresentationRepairer getRepairer(String contentType) {
91		return getDelegate().getRepairer(contentType);
92		}
93
94		}
95		private Map<IConfigurationElement, PresentationReconcilerExtension> extensions = new HashMap<>();
	40	private Map<IConfigurationElement, GenericContentTypeRelatedExtension<IPresentationReconciler>> extensions = new HashMap<>();
96	41	private boolean outOfSync = true;
97	42
98	43	/**

111	56	* Get the contributed {@link IPresentationReconciliers}s that are relevant to hook on source viewer according
112	57	* to document content types.
113	58	* @param sourceViewer the source viewer we're hooking completion to.
	59	* @param editor the text editor
114	60	* @param contentTypes the content types of the document we're editing.
115	61	* @return the list of {@link IPresentationReconciler} contributed for at least one of the content types.
116	62	*/
117		public List<IPresentationReconciler> getPresentationReconcilers(ISourceViewer sourceViewer, Set<IContentType> contentTypes) {
	63	public List<IPresentationReconciler> getPresentationReconcilers(ISourceViewer sourceViewer, ITextEditor editor, Set<IContentType> contentTypes) {
118	64	if (this.outOfSync) {
119	65	sync();
120	66	}
121		List<IPresentationReconciler> res = new ArrayList<>();
122		for (PresentationReconcilerExtension ext : this.extensions.values()) {
123		if (contentTypes.contains(ext.targetContentType)) {
124		res.add(ext);
125		}
126		}
127		return res;
	67	return this.extensions.values().stream()
	68	.filter(ext -> contentTypes.contains(ext.targetContentType))
	69	.filter(ext -> ext.matches(sourceViewer, editor))
	70	.sorted(new ContentTypeSpecializationComparator<IPresentationReconciler>())
	71	.map(GenericContentTypeRelatedExtension<IPresentationReconciler>::createDelegate)
	72	.collect(Collectors.toList());
128	73	}
129	74
130	75	private void sync() {

133	78	toRemoveExtensions.remove(extension);
134	79	if (!this.extensions.containsKey(extension)) {
135	80	try {
136		this.extensions.put(extension, new PresentationReconcilerExtension(extension));
	81	this.extensions.put(extension, new GenericContentTypeRelatedExtension<IPresentationReconciler>(extension));
137	82	} catch (Exception ex) {
138	83	GenericEditorPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID, ex.getMessage(), ex));
139	84	}

+139

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/ReconcilerRegistry.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import java.util.HashMap;
	13	import java.util.HashSet;
	14	import java.util.List;
	15	import java.util.Map;
	16	import java.util.Set;
	17	import java.util.stream.Collectors;
	18
	19	import org.eclipse.core.runtime.IConfigurationElement;
	20	import org.eclipse.core.runtime.IStatus;
	21	import org.eclipse.core.runtime.Platform;
	22	import org.eclipse.core.runtime.Status;
	23	import org.eclipse.core.runtime.content.IContentType;
	24	import org.eclipse.jface.text.reconciler.IReconciler;
	25	import org.eclipse.jface.text.source.ISourceViewer;
	26	import org.eclipse.ui.texteditor.ITextEditor;
	27
	28	/**
	29	* A registry of reconciliers provided by extensions <code>org.eclipse.ui.genericeditor.reconcilers</code>
	30	* and <code>org.eclipse.ui.genericeditor.foldingReconcilers</code>.
	31	* Those extensions are specific to a given {@link IContentType}.
	32	*
	33	* @since 1.1
	34	*/
	35	public class ReconcilerRegistry {
	36
	37	private static final String EXTENSION_POINT_ID = GenericEditorPlugin.BUNDLE_ID + ".reconcilers"; //$NON-NLS-1$
	38	private static final String HIGHLIGHT_EXTENSION_POINT_ID = GenericEditorPlugin.BUNDLE_ID + ".highlightReconcilers"; //$NON-NLS-1$
	39
	40	private Map<IConfigurationElement, GenericContentTypeRelatedExtension<IReconciler>> extensions = new HashMap<>();
	41	private Map<IConfigurationElement, GenericContentTypeRelatedExtension<IReconciler>> highlightExtensions = new HashMap<>();
	42	private boolean outOfSync = true;
	43	private boolean highlightOutOfSync = true;
	44
	45	/**
	46	* Creates the registry and binds it to the extension point.
	47	*/
	48	public ReconcilerRegistry() {
	49	Platform.getExtensionRegistry().addRegistryChangeListener(event -> {
	50	outOfSync = true;
	51	}, EXTENSION_POINT_ID);
	52
	53	Platform.getExtensionRegistry().addRegistryChangeListener(event -> {
	54	highlightOutOfSync = true;
	55	}, HIGHLIGHT_EXTENSION_POINT_ID);
	56	}
	57
	58	/**
	59	* Get the contributed {@link IReconciliers}s that are relevant to hook on source viewer according
	60	* to document content types.
	61	* @param sourceViewer the source viewer we're hooking completion to.
	62	* @param editor the text editor
	63	* @param contentTypes the content types of the document we're editing.
	64	* @return the list of {@link IReconciler} contributed for at least one of the content types,
	65	* sorted by most generic content type to most specific.
	66	*/
	67	public List<IReconciler> getReconcilers(ISourceViewer sourceViewer, ITextEditor editor, Set<IContentType> contentTypes) {
	68	if (this.outOfSync) {
	69	sync();
	70	}
	71	List<IReconciler> reconcilers = this.extensions.values().stream()
	72	.filter(ext -> contentTypes.contains(ext.targetContentType))
	73	.filter(ext -> ext.matches(sourceViewer, editor))
	74	.sorted(new ContentTypeSpecializationComparator<IReconciler>().reversed())
	75	.map(GenericContentTypeRelatedExtension<IReconciler>::createDelegate)
	76	.collect(Collectors.toList());
	77	return reconcilers;
	78	}
	79
	80	/**
	81	* Get the contributed highlight {@link IReconciliers}s that are relevant to hook on source viewer according
	82	* to document content types.
	83	* @param sourceViewer the source viewer we're hooking completion to.
	84	* @param editor the text editor
	85	* @param contentTypes the content types of the document we're editing.
	86	* @return the list of highlight {@link IReconciler}s contributed for at least one of the content types,
	87	* sorted by most generic content type to most specific.
	88	*/
	89	public List<IReconciler> getHighlightReconcilers(ISourceViewer sourceViewer, ITextEditor editor, Set<IContentType> contentTypes) {
	90	if (this.highlightOutOfSync) {
	91	syncHighlight();
	92	}
	93	List<IReconciler> highlightReconcilers = this.highlightExtensions.values().stream()
	94	.filter(ext -> contentTypes.contains(ext.targetContentType))
	95	.filter(ext -> ext.matches(sourceViewer, editor))
	96	.sorted(new ContentTypeSpecializationComparator<IReconciler>().reversed())
	97	.map(GenericContentTypeRelatedExtension<IReconciler>::createDelegate)
	98	.collect(Collectors.toList());
	99	return highlightReconcilers;
	100	}
	101
	102	private void sync() {
	103	Set<IConfigurationElement> toRemoveExtensions = new HashSet<>(this.extensions.keySet());
	104	for (IConfigurationElement extension : Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_POINT_ID)) {
	105	toRemoveExtensions.remove(extension);
	106	if (!this.extensions.containsKey(extension)) {
	107	try {
	108	this.extensions.put(extension, new GenericContentTypeRelatedExtension<IReconciler>(extension));
	109	} catch (Exception ex) {
	110	GenericEditorPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID, ex.getMessage(), ex));
	111	}
	112	}
	113	}
	114	for (IConfigurationElement toRemove : toRemoveExtensions) {
	115	this.extensions.remove(toRemove);
	116	}
	117	this.outOfSync = false;
	118	}
	119
	120	private void syncHighlight() {
	121	Set<IConfigurationElement> toRemoveExtensions = new HashSet<>(this.extensions.keySet());
	122	for (IConfigurationElement extension : Platform.getExtensionRegistry().getConfigurationElementsFor(HIGHLIGHT_EXTENSION_POINT_ID)) {
	123	toRemoveExtensions.remove(extension);
	124	if (!this.highlightExtensions.containsKey(extension)) {
	125	try {
	126	this.highlightExtensions.put(extension, new GenericContentTypeRelatedExtension<IReconciler>(extension));
	127	} catch (Exception ex) {
	128	GenericEditorPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID, ex.getMessage(), ex));
	129	}
	130	}
	131	}
	132	for (IConfigurationElement toRemove : toRemoveExtensions) {
	133	this.highlightExtensions.remove(toRemove);
	134	}
	135	this.highlightOutOfSync = false;
	136	}
	137
	138	}

+0

-155

~~org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/TextHoverRegistry.java~~ less more

0		/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others.
2		* All rights reserved. This program and the accompanying materials
3		* are made available under the terms of the Eclipse Public License v1.0
4		* which accompanies this distribution, and is available at
5		* http://www.eclipse.org/legal/epl-v10.html
6		*
7		* Contributors:
8		* - Mickael Istria (Red Hat Inc.)
9		*******************************************************************************/
10		package org.eclipse.ui.internal.genericeditor;
11
12		import java.util.ArrayList;
13		import java.util.HashMap;
14		import java.util.HashSet;
15		import java.util.List;
16		import java.util.Map;
17		import java.util.Set;
18		import java.util.SortedSet;
19		import java.util.TreeSet;
20		import java.util.function.Function;
21		import java.util.stream.Collectors;
22
23		import org.eclipse.core.runtime.CoreException;
24		import org.eclipse.core.runtime.IConfigurationElement;
25		import org.eclipse.core.runtime.IRegistryChangeEvent;
26		import org.eclipse.core.runtime.IRegistryChangeListener;
27		import org.eclipse.core.runtime.IStatus;
28		import org.eclipse.core.runtime.Platform;
29		import org.eclipse.core.runtime.Status;
30		import org.eclipse.core.runtime.content.IContentType;
31		import org.eclipse.jface.preference.IPreferenceStore;
32		import org.eclipse.jface.text.ITextHover;
33		import org.eclipse.jface.text.source.ISourceViewer;
34
35		/**
36		* Text hover registry that manages the detectors
37		* contributed by the <code>org.eclipse.ui.workbench.texteditor.hoverProvider</code> extension point for
38		* targets contributed by the <code>org.eclipse.ui.workbench.texteditor.hyperlinkDetectorTargets</code> extension point.
39		*
40		* @since 1.0
41		*/
42		public final class TextHoverRegistry {
43
44		private static final String EXTENSION_POINT_ID = GenericEditorPlugin.BUNDLE_ID + ".hoverProviders"; //$NON-NLS-1$
45
46		private SortedSet<TextHoverExtension> extensions;
47		private boolean outOfSync = true;
48
49		static class TextHoverExtension {
50		private static final String CONTENT_TYPE_ATTRIBUTE = "contentType"; //$NON-NLS-1$
51		private static final String CLASS_ATTRIBUTE = "class"; //$NON-NLS-1$
52		private static final String ID_ATTRIBUTE = "id"; //$NON-NLS-1$
53		private static final String IS_BEFORE_ATTRIBUTE = "isBefore"; //$NON-NLS-1$
54		private static final String IS_AFTER_ATTRIBUTE = "isAfter"; //$NON-NLS-1$
55
56		private IConfigurationElement extension;
57		private IContentType targetContentType;
58		private ITextHover delegate;
59		private String id;
60		private String isBefore;
61		private String isAfter;
62
63		public TextHoverExtension(IConfigurationElement extension) throws Exception {
64		this.extension = extension;
65		this.targetContentType = Platform.getContentTypeManager().getContentType(extension.getAttribute(CONTENT_TYPE_ATTRIBUTE));
66		this.id = extension.getAttribute(ID_ATTRIBUTE);
67		this.isBefore = extension.getAttribute(IS_BEFORE_ATTRIBUTE);
68		this.isAfter = extension.getAttribute(IS_AFTER_ATTRIBUTE);
69		}
70
71		public ITextHover getDelegate() {
72		if (this.delegate == null) {
73		try {
74		this.delegate = (ITextHover) extension.createExecutableExtension(CLASS_ATTRIBUTE);
75		} catch (CoreException e) {
76		e.printStackTrace();
77		}
78		}
79		return delegate;
80		}
81
82		public String getId() {
83		if (this.id != null) {
84		return this.id;
85		}
86		return this.extension.getContributor().getName() + '@' + toString();
87		}
88
89		public String getIsAfter() {
90		return this.isAfter;
91		}
92
93		public String getIsBefore() {
94		return this.isBefore;
95		}
96
97		IConfigurationElement getConfigurationElement() {
98		return this.extension;
99		}
100		}
101
102		public TextHoverRegistry(IPreferenceStore preferenceStore) {
103		Platform.getExtensionRegistry().addRegistryChangeListener(new IRegistryChangeListener() {
104		@Override
105		public void registryChanged(IRegistryChangeEvent event) {
106		outOfSync = true;
107		}
108		}, EXTENSION_POINT_ID);
109		}
110
111		public ITextHover getAvailableHover(ISourceViewer sourceViewer, Set<IContentType> contentTypes) {
112		if (this.outOfSync) {
113		sync();
114		}
115		List<TextHoverExtension> hoversToConsider = new ArrayList<>();
116		for (TextHoverExtension ext : this.extensions) {
117		if (contentTypes.contains(ext.targetContentType)) {
118		hoversToConsider.add(ext);
119		}
120		}
121		if (!hoversToConsider.isEmpty()) {
122		return new CompositeTextHover(hoversToConsider);
123		}
124		return null;
125		}
126
127		private void sync() {
128		Set<IConfigurationElement> toRemoveExtensions = new HashSet<>();
129		Map<IConfigurationElement, TextHoverExtension> ext = new HashMap<>();
130		if (this.extensions != null) {
131		ext = this.extensions.stream().collect(Collectors.toMap(TextHoverExtension::getConfigurationElement, Function.identity()));
132		toRemoveExtensions = ext.keySet();
133		}
134		for (IConfigurationElement extension : Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_POINT_ID)) {
135		toRemoveExtensions.remove(extension);
136		if (!ext.containsKey(extension)) {
137		try {
138		ext.put(extension, new TextHoverExtension(extension));
139		} catch (Exception ex) {
140		GenericEditorPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID, ex.getMessage(), ex));
141		}
142		}
143		}
144		for (IConfigurationElement toRemove : toRemoveExtensions) {
145		ext.remove(toRemove);
146		}
147
148		OrderedExtensionComparator comparator = new OrderedExtensionComparator(ext.values());
149		this.extensions = new TreeSet<>(comparator);
150		this.extensions.addAll(ext.values());
151		this.outOfSync = false;
152		}
153
154		}

+34

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/ToggleHighlight.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor;
	11
	12	import org.eclipse.core.commands.AbstractHandler;
	13	import org.eclipse.core.commands.Command;
	14	import org.eclipse.core.commands.ExecutionEvent;
	15	import org.eclipse.core.commands.ExecutionException;
	16	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
	17	import org.eclipse.core.runtime.preferences.InstanceScope;
	18	import org.eclipse.ui.handlers.HandlerUtil;
	19
	20	public class ToggleHighlight extends AbstractHandler {
	21
	22	public static final String TOGGLE_HIGHLIGHT_PREFERENCE = "org.eclipse.ui.genericeditor.togglehighlight"; //$NON-NLS-1$
	23
	24	@Override
	25	public Object execute(ExecutionEvent event) throws ExecutionException {
	26	Command command = event.getCommand();
	27	boolean oldValue = HandlerUtil.toggleCommandState(command);
	28
	29	IEclipsePreferences preferences = InstanceScope.INSTANCE.getNode(GenericEditorPlugin.BUNDLE_ID);
	30	preferences.putBoolean(TOGGLE_HIGHLIGHT_PREFERENCE, !oldValue);
	31	return null;
	32	}
	33	}

+160

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/hover/CompositeInformationControl.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Mickael Istria (Red Hat Inc.)
	9	* - Lucas Bullen (Red Hat Inc.) - [Bug 527071] Empty string as content breaks hover
	10	*******************************************************************************/
	11	package org.eclipse.ui.internal.genericeditor.hover;
	12
	13	import java.util.Arrays;
	14	import java.util.LinkedHashMap;
	15	import java.util.List;
	16	import java.util.Map;
	17	import java.util.Map.Entry;
	18
	19	import org.eclipse.core.runtime.Assert;
	20	import org.eclipse.core.runtime.IStatus;
	21	import org.eclipse.core.runtime.Status;
	22	import org.eclipse.jface.text.AbstractInformationControl;
	23	import org.eclipse.jface.text.IInformationControl;
	24	import org.eclipse.jface.text.IInformationControlCreator;
	25	import org.eclipse.jface.text.IInformationControlExtension;
	26	import org.eclipse.jface.text.IInformationControlExtension2;
	27	import org.eclipse.jface.text.IInformationControlExtension5;
	28	import org.eclipse.jface.text.ITextHover;
	29	import org.eclipse.swt.SWT;
	30	import org.eclipse.swt.graphics.Point;
	31	import org.eclipse.swt.layout.GridData;
	32	import org.eclipse.swt.layout.GridLayout;
	33	import org.eclipse.swt.widgets.Composite;
	34	import org.eclipse.swt.widgets.Control;
	35	import org.eclipse.swt.widgets.Shell;
	36	import org.eclipse.ui.internal.genericeditor.GenericEditorPlugin;
	37
	38	public class CompositeInformationControl extends AbstractInformationControl implements IInformationControlExtension2 {
	39
	40	final LinkedHashMap<ITextHover, IInformationControlCreator> creators;
	41	LinkedHashMap<ITextHover, IInformationControl> controls;
	42
	43	public CompositeInformationControl(Shell parentShell, LinkedHashMap<ITextHover, IInformationControlCreator> creators) {
	44	super(parentShell, true); // TODO check best constructor
	45	Assert.isLegal(creators.size() > 1, "Do not compose a unique hover"); //$NON-NLS-1$
	46	this.creators = creators;
	47	create();
	48	}
	49
	50	@Override
	51	public boolean hasContents() {
	52	for (IInformationControl control : controls.values()) {
	53	if (control instanceof IInformationControlExtension) {
	54	if (((IInformationControlExtension)control).hasContents()) {
	55	return true;
	56	}
	57	} else {
	58	return true;
	59	}
	60	}
	61	return false;
	62	}
	63
	64	@Override
	65	public void setInput(Object input) {
	66	@SuppressWarnings("unchecked")
	67	Map<ITextHover, Object> inputs = (Map<ITextHover, Object>)input;
	68	for (Entry<ITextHover, Object> entry : inputs.entrySet()) {
	69	IInformationControl informationControl = controls.get(entry.getKey());
	70	if (informationControl != null) {
	71	if (informationControl instanceof IInformationControlExtension2) {
	72	((IInformationControlExtension2)informationControl).setInput(entry.getValue());
	73	continue;
	74	}
	75	String information = entry.getValue().toString();
	76	if(!information.isEmpty()){
	77	informationControl.setInformation(information);
	78	}
	79	}
	80	}
	81	}
	82
	83	@Override
	84	public void createContent(Composite parent) {
	85	this.controls = new LinkedHashMap<>(); // TODO maybe use canReuse or canReplace
	86	GridLayout layout = new GridLayout(1, false);
	87	parent.setLayout(layout);
	88	boolean firstControl = true;
	89	for (Entry<ITextHover, IInformationControlCreator> hoverControlCreator : this.creators.entrySet()) {
	90	IInformationControl informationControl = hoverControlCreator.getValue().createInformationControl(parent.getShell());
	91	if (informationControl instanceof AbstractInformationControl) {
	92	List<Control> children = Arrays.asList(((AbstractInformationControl)informationControl).getShell().getChildren());
	93	children.remove(parent);
	94	if (children.size() == 0 ) {
	95	continue;
	96	}
	97	for (Control control : children) {
	98	control.setParent(parent);
	99	control.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
	100	}
	101	if (!firstControl) {
	102	((GridData)children.get(0).getLayoutData()).verticalIndent = 15;
	103	}
	104	controls.put(hoverControlCreator.getKey(), informationControl);
	105	firstControl = false;
	106	} else {
	107	GenericEditorPlugin.getDefault().getLog().log(new Status(IStatus.WARNING, GenericEditorPlugin.BUNDLE_ID,
	108	"Only text hovers producing an AbstractInformationControl can be aggregated; got a " + informationControl.getClass().getSimpleName())); //$NON-NLS-1$
	109	informationControl.dispose();
	110	}
	111	}
	112	}
	113
	114	@Override
	115	public void dispose() {
	116	controls.values().forEach(IInformationControl::dispose);
	117	controls.clear();
	118	super.dispose();
	119	}
	120
	121	@Override
	122	public IInformationControlCreator getInformationPresenterControlCreator() {
	123	if (controls.isEmpty()) {
	124	return null;
	125	} else if (controls.size() == 1) {
	126	IInformationControl control = controls.values().iterator().next();
	127	if (control instanceof IInformationControlExtension5) {
	128	return ((IInformationControlExtension5)control).getInformationPresenterControlCreator();
	129	}
	130	} else {
	131	LinkedHashMap<ITextHover, IInformationControlCreator> presenterCreators = new LinkedHashMap<>();
	132	boolean allNull = true;
	133	for (Entry<ITextHover, IInformationControl> hover : this.controls.entrySet()) {
	134	IInformationControlCreator creator = null;
	135	if (hover.getValue() instanceof IInformationControlExtension5)
	136	creator = ((IInformationControlExtension5)hover.getValue()).getInformationPresenterControlCreator();
	137	if (creator == null) {
	138	creator = this.creators.get(hover.getKey());
	139	} else {
	140	allNull = false;
	141	}
	142	if (creator != null) {
	143	presenterCreators.put(hover.getKey(), creator);
	144	}
	145	}
	146	if (allNull) {
	147	return null;
	148	}
	149	return new CompositeInformationControlCreator(presenterCreators);
	150	}
	151	return null;
	152	}
	153
	154	@Override
	155	public Point computeSizeHint() {
	156	return getShell().computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
	157	}
	158
	159	}

+120

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/hover/CompositeInformationControlCreator.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Mickael Istria (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor.hover;
	11
	12	import java.util.Iterator;
	13	import java.util.LinkedHashMap;
	14	import java.util.List;
	15	import java.util.Map.Entry;
	16
	17	import org.eclipse.jface.text.AbstractReusableInformationControlCreator;
	18	import org.eclipse.jface.text.DefaultInformationControl;
	19	import org.eclipse.jface.text.IInformationControl;
	20	import org.eclipse.jface.text.IInformationControlCreator;
	21	import org.eclipse.jface.text.IInformationControlCreatorExtension;
	22	import org.eclipse.jface.text.ITextHover;
	23	import org.eclipse.jface.text.ITextHoverExtension;
	24	import org.eclipse.swt.widgets.Shell;
	25
	26	public class CompositeInformationControlCreator
	27	implements IInformationControlCreator, IInformationControlCreatorExtension {
	28
	29	private final LinkedHashMap<ITextHover, IInformationControlCreator> creators;
	30
	31	public CompositeInformationControlCreator(List<ITextHover> hovers) {
	32	this.creators = new LinkedHashMap<>();
	33	for (ITextHover hover : hovers) {
	34	creators.put(hover, getInformationControlCreator(hover));
	35	}
	36	}
	37
	38	public CompositeInformationControlCreator(LinkedHashMap<ITextHover, IInformationControlCreator> creators) {
	39	this.creators = creators;
	40	}
	41
	42	private static IInformationControlCreator getInformationControlCreator(ITextHover hover) {
	43	IInformationControlCreator controlCreator = null;
	44	if (hover instanceof ITextHoverExtension) {
	45	controlCreator = ((ITextHoverExtension)hover).getHoverControlCreator();
	46	}
	47	if (controlCreator == null) {
	48	controlCreator = new AbstractReusableInformationControlCreator() {
	49	@Override
	50	protected IInformationControl doCreateInformationControl(Shell parent) {
	51	return new DefaultInformationControl(parent, true);
	52	}
	53	};
	54	}
	55	return controlCreator;
	56	}
	57
	58
	59	@Override
	60	public boolean canReuse(IInformationControl control) {
	61	if (control.getClass() != CompositeInformationControl.class) {
	62	return false;
	63	}
	64	CompositeInformationControl other = (CompositeInformationControl)control;
	65	if (!other.creators.equals(this.creators)) {
	66	return false;
	67	}
	68	Iterator<Entry<ITextHover, IInformationControlCreator>> thisIterator = this.creators.entrySet().iterator();
	69	Iterator<Entry<ITextHover, IInformationControl>> otherIterator = other.controls.entrySet().iterator();
	70	do {
	71	Entry<ITextHover, IInformationControlCreator> thisEntry = thisIterator.next();
	72	Entry<ITextHover, IInformationControl> otherEntry = otherIterator.next();
	73	if (!thisEntry.getKey().equals(otherEntry.getKey())) {
	74	return false;
	75	}
	76	if (!(thisEntry.getValue() instanceof IInformationControlCreatorExtension)) {
	77	return false;
	78	}
	79	if (!((IInformationControlCreatorExtension)thisEntry.getValue()).canReuse(otherEntry.getValue())) {
	80	return false;
	81	}
	82	} while (thisIterator.hasNext());
	83	return true;
	84	}
	85
	86	@Override
	87	public boolean canReplace(IInformationControlCreator creator) {
	88	if (creator.getClass() != this.getClass()) {
	89	return false;
	90	}
	91	CompositeInformationControlCreator other = (CompositeInformationControlCreator)creator;
	92	if (other.creators.size() != this.creators.size()) {
	93	return false;
	94	}
	95	Iterator<Entry<ITextHover, IInformationControlCreator>> thisIterator = this.creators.entrySet().iterator();
	96	Iterator<Entry<ITextHover, IInformationControlCreator>> otherIterator = other.creators.entrySet().iterator();
	97	do {
	98	Entry<ITextHover, IInformationControlCreator> thisEntry = thisIterator.next();
	99	Entry<ITextHover, IInformationControlCreator> otherEntry = otherIterator.next();
	100	if (!thisEntry.getKey().equals(otherEntry.getKey())) {
	101	return false;
	102	}
	103	if (!(thisEntry.getValue() instanceof IInformationControlCreatorExtension)) {
	104	return false;
	105	}
	106	if (!((IInformationControlCreatorExtension)thisEntry.getValue()).canReplace(otherEntry.getValue())) {
	107	return false;
	108	}
	109	} while (thisIterator.hasNext());
	110	return true;
	111	}
	112
	113
	114	@Override
	115	public IInformationControl createInformationControl(Shell parent) {
	116	return new CompositeInformationControl(parent, this.creators);
	117	}
	118
	119	}

+113

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/hover/CompositeTextHover.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2016-2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Mickael Istria (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor.hover;
	11
	12	import java.util.ArrayList;
	13	import java.util.Collections;
	14	import java.util.LinkedHashMap;
	15	import java.util.List;
	16	import java.util.Objects;
	17	import java.util.stream.Collectors;
	18
	19	import org.eclipse.core.runtime.Assert;
	20	import org.eclipse.jface.text.IInformationControlCreator;
	21	import org.eclipse.jface.text.IRegion;
	22	import org.eclipse.jface.text.ITextHover;
	23	import org.eclipse.jface.text.ITextHoverExtension;
	24	import org.eclipse.jface.text.ITextHoverExtension2;
	25	import org.eclipse.jface.text.ITextViewer;
	26	import org.eclipse.jface.text.Region;
	27
	28	/**
	29	* A text hover that delegates its operations to children
	30	* provided in constructor and returns the first interesting result.
	31	*
	32	* @since 1.0
	33	*/
	34	public class CompositeTextHover implements ITextHover, ITextHoverExtension, ITextHoverExtension2 {
	35
	36	private final List<ITextHover> allHovers;
	37	private LinkedHashMap<ITextHover, IRegion> regions = null;
	38	private LinkedHashMap<ITextHover, Object> currentHovers = null;
	39
	40	public CompositeTextHover(List<ITextHover> hoversToConsider) {
	41	Assert.isNotNull(hoversToConsider);
	42	Assert.isLegal(hoversToConsider.size() > 1, "Do not compose a single hover."); //$NON-NLS-1$
	43	this.allHovers = Collections.unmodifiableList(hoversToConsider);
	44	}
	45
	46	@Override
	47	public Object getHoverInfo2(ITextViewer textViewer, IRegion requestRegion) {
	48	this.currentHovers = new LinkedHashMap<>();
	49	for (ITextHover hover : this.allHovers) {
	50	IRegion currentRegion = this.regions.get(hover);
	51	if (currentRegion == null) {
	52	continue;
	53	}
	54	Object res = hover instanceof ITextHoverExtension2 ?
	55	((ITextHoverExtension2)hover).getHoverInfo2(textViewer, currentRegion) :
	56	hover.getHoverInfo(textViewer, currentRegion);
	57	if (res != null) {
	58	this.currentHovers.put(hover, res);
	59	}
	60	}
	61	if (this.currentHovers.isEmpty()) {
	62	return null;
	63	} else if (this.currentHovers.size() == 1) {
	64	return this.currentHovers.values().iterator().next();
	65	} else {
	66	return this.currentHovers;
	67	}
	68	}
	69
	70	@Override
	71	public IInformationControlCreator getHoverControlCreator() {
	72	if (this.currentHovers == null \|\| this.currentHovers.isEmpty()) {
	73	return null;
	74	} else if (currentHovers.size() == 1) {
	75	ITextHover hover = this.currentHovers.keySet().iterator().next();
	76	return hover instanceof ITextHoverExtension ?
	77	((ITextHoverExtension)hover).getHoverControlCreator():
	78	null;
	79	} else {
	80	return new CompositeInformationControlCreator(new ArrayList<>(this.currentHovers.keySet()));
	81	}
	82	}
	83
	84	@Override
	85	public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {
	86	return this.allHovers.stream()
	87	.map(hover -> hover.getHoverInfo(textViewer, this.regions.get(hover)))
	88	.filter(Objects::nonNull)
	89	.collect(Collectors.joining("\n")); //$NON-NLS-1$
	90	}
	91
	92	@Override
	93	public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
	94	this.regions = new LinkedHashMap<>();
	95	IRegion res = null;
	96	for (ITextHover hover : this.allHovers) {
	97	IRegion region = hover.getHoverRegion(textViewer, offset);
	98	if (region != null) {
	99	this.regions.put(hover, region);
	100	if (res == null) {
	101	res = region;
	102	} else {
	103	int startOffset = Math.max(res.getOffset(), region.getOffset());
	104	int endOffset = Math.min(res.getOffset() + res.getLength(), region.getOffset() + region.getLength());
	105	res = new Region(startOffset, endOffset - startOffset);
	106	}
	107	}
	108	}
	109	return res;
	110	}
	111
	112	}

+91

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/hover/OrderedExtensionComparator.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2016 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Mickael Istria (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor.hover;
	11
	12	import java.util.Collection;
	13	import java.util.Comparator;
	14	import java.util.Map;
	15	import java.util.function.Function;
	16	import java.util.stream.Collectors;
	17
	18	import org.eclipse.core.runtime.Assert;
	19	import org.eclipse.ui.internal.genericeditor.hover.TextHoverRegistry.TextHoverExtension;
	20
	21	/**
	22	* A comparator that allows to sort elements according to their relative
	23	* placement (isBefore and isAfter)
	24	*TODO: generalizing to any kind of extension supporting isBefore and isAfter
	25	*/
	26	class OrderedExtensionComparator implements Comparator<TextHoverExtension> {
	27
	28	private Map<String, TextHoverExtension> extensionsById;
	29
	30	public OrderedExtensionComparator(Collection<TextHoverExtension> extensions) {
	31	Assert.isNotNull(extensions);
	32	this.extensionsById = extensions.stream().collect(Collectors.toMap(TextHoverExtension::getId, Function.identity()));
	33	}
	34
	35	@Override
	36	public int compare(TextHoverExtension arg0, TextHoverExtension arg1) {
	37	if (isDeclaredAsBefore(arg0, arg1) \|\| isDeclaredAsAfter(arg1, arg0)) {
	38	return -1;
	39	}
	40	if (isDeclaredAsAfter(arg0, arg1) \|\| isDeclaredAsBefore(arg1, arg0)) {
	41	return +1;
	42	}
	43	return arg0.toString().compareTo(arg1.toString());
	44	}
	45
	46	private boolean isDeclaredAsBefore(TextHoverExtension arg0, TextHoverExtension arg1) {
	47	String before0 = arg0.getIsBefore();
	48	if (before0 == null) {
	49	return false;
	50	}
	51	if ("".equals(before0) && !"".equals(arg1.getIsBefore())) { //$NON-NLS-1$ //$NON-NLS-2$
	52	return true;
	53	}
	54	String id1 = arg1.getId();
	55	if (id1 == null) {
	56	return false;
	57	}
	58	if (before0.equals(id1)) {
	59	return true;
	60	}
	61	String after1 = arg1.getIsAfter();
	62	if (after1 == null) {
	63	return false;
	64	}
	65	return isDeclaredAsAfter(arg0, this.extensionsById.get(after1));
	66	}
	67
	68	private boolean isDeclaredAsAfter(TextHoverExtension arg0, TextHoverExtension arg1) {
	69	String after0 = arg0.getIsAfter();
	70	if (after0 == null) {
	71	return false;
	72	}
	73	if ("".equals(after0) && !"".equals(arg1.getIsAfter())) { //$NON-NLS-1$ //$NON-NLS-2$
	74	return true;
	75	}
	76	String id1 = arg1.getId();
	77	if (id1 == null) {
	78	return false;
	79	}
	80	if (after0.equals(id1)) {
	81	return true;
	82	}
	83	String before1 = arg1.getIsBefore();
	84	if (before1 == null) {
	85	return false;
	86	}
	87	return isDeclaredAsAfter(arg0, this.extensionsById.get(before1));
	88	}
	89
	90	}⏎

+135

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/hover/TextHoverRegistry.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2016-2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Mickael Istria (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.internal.genericeditor.hover;
	11
	12	import java.util.HashMap;
	13	import java.util.HashSet;
	14	import java.util.List;
	15	import java.util.Map;
	16	import java.util.Set;
	17	import java.util.SortedSet;
	18	import java.util.TreeSet;
	19	import java.util.function.Function;
	20	import java.util.stream.Collectors;
	21
	22	import org.eclipse.core.runtime.IConfigurationElement;
	23	import org.eclipse.core.runtime.IRegistryChangeEvent;
	24	import org.eclipse.core.runtime.IRegistryChangeListener;
	25	import org.eclipse.core.runtime.IStatus;
	26	import org.eclipse.core.runtime.Platform;
	27	import org.eclipse.core.runtime.Status;
	28	import org.eclipse.core.runtime.content.IContentType;
	29	import org.eclipse.jface.preference.IPreferenceStore;
	30	import org.eclipse.jface.text.ITextHover;
	31	import org.eclipse.jface.text.source.ISourceViewer;
	32	import org.eclipse.ui.internal.genericeditor.GenericContentTypeRelatedExtension;
	33	import org.eclipse.ui.internal.genericeditor.GenericEditorPlugin;
	34	import org.eclipse.ui.texteditor.ITextEditor;
	35
	36	/**
	37	* Text hover registry that manages the detectors
	38	* contributed by the <code>org.eclipse.ui.workbench.texteditor.hoverProvider</code> extension point for
	39	* targets contributed by the <code>org.eclipse.ui.workbench.texteditor.hyperlinkDetectorTargets</code> extension point.
	40	*
	41	* @since 1.0
	42	*/
	43	public final class TextHoverRegistry {
	44
	45	private static final String EXTENSION_POINT_ID = GenericEditorPlugin.BUNDLE_ID + ".hoverProviders"; //$NON-NLS-1$
	46
	47	private SortedSet<TextHoverExtension> extensions;
	48	private boolean outOfSync = true;
	49
	50	static class TextHoverExtension extends GenericContentTypeRelatedExtension<ITextHover> {
	51	private static final String ID_ATTRIBUTE = "id"; //$NON-NLS-1$
	52	private static final String IS_BEFORE_ATTRIBUTE = "isBefore"; //$NON-NLS-1$
	53	private static final String IS_AFTER_ATTRIBUTE = "isAfter"; //$NON-NLS-1$
	54
	55	private String id;
	56	private String isBefore;
	57	private String isAfter;
	58
	59	public TextHoverExtension(IConfigurationElement extension) throws Exception {
	60	super(extension);
	61	this.id = extension.getAttribute(ID_ATTRIBUTE);
	62	this.isBefore = extension.getAttribute(IS_BEFORE_ATTRIBUTE);
	63	this.isAfter = extension.getAttribute(IS_AFTER_ATTRIBUTE);
	64	}
	65
	66	public String getId() {
	67	if (this.id != null) {
	68	return this.id;
	69	}
	70	return this.extension.getContributor().getName() + '@' + toString();
	71	}
	72
	73	public String getIsAfter() {
	74	return this.isAfter;
	75	}
	76
	77	public String getIsBefore() {
	78	return this.isBefore;
	79	}
	80
	81	IConfigurationElement getConfigurationElement() {
	82	return this.extension;
	83	}
	84	}
	85
	86	public TextHoverRegistry(IPreferenceStore preferenceStore) {
	87	Platform.getExtensionRegistry().addRegistryChangeListener(new IRegistryChangeListener() {
	88	@Override
	89	public void registryChanged(IRegistryChangeEvent event) {
	90	outOfSync = true;
	91	}
	92	}, EXTENSION_POINT_ID);
	93	}
	94
	95	public List<ITextHover> getAvailableHovers(ISourceViewer sourceViewer, ITextEditor editor, Set<IContentType> contentTypes) {
	96	if (this.outOfSync) {
	97	sync();
	98	}
	99	return this.extensions.stream()
	100	.filter(ext -> contentTypes.contains(ext.targetContentType))
	101	.filter(ext -> ext.matches(sourceViewer, editor))
	102	// don't sort in the stream as the initial structure is already sorted by isAfter/isBefore
	103	.map(GenericContentTypeRelatedExtension<ITextHover>::createDelegate)
	104	.collect(Collectors.toList());
	105	}
	106
	107	private void sync() {
	108	Set<IConfigurationElement> toRemoveExtensions = new HashSet<>();
	109	Map<IConfigurationElement, TextHoverExtension> ext = new HashMap<>();
	110	if (this.extensions != null) {
	111	ext = this.extensions.stream().collect(Collectors.toMap(TextHoverExtension::getConfigurationElement, Function.identity()));
	112	toRemoveExtensions = ext.keySet();
	113	}
	114	for (IConfigurationElement extension : Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_POINT_ID)) {
	115	toRemoveExtensions.remove(extension);
	116	if (!ext.containsKey(extension)) {
	117	try {
	118	ext.put(extension, new TextHoverExtension(extension));
	119	} catch (Exception ex) {
	120	GenericEditorPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, GenericEditorPlugin.BUNDLE_ID, ex.getMessage(), ex));
	121	}
	122	}
	123	}
	124	for (IConfigurationElement toRemove : toRemoveExtensions) {
	125	ext.remove(toRemove);
	126	}
	127
	128	OrderedExtensionComparator comparator = new OrderedExtensionComparator(ext.values());
	129	this.extensions = new TreeSet<>(comparator);
	130	this.extensions.addAll(ext.values());
	131	this.outOfSync = false;
	132	}
	133
	134	}

+13

-3

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/markers/MarkerHoverControlCreator.java less more

16	16
17	17	public class MarkerHoverControlCreator implements IInformationControlCreator, IInformationControlCreatorExtension {
18	18
	19	private final boolean showAffordanceString;
	20
	21	public MarkerHoverControlCreator() {
	22	this(true);
	23	}
	24
	25	public MarkerHoverControlCreator(boolean showAffordanceString) {
	26	this.showAffordanceString = showAffordanceString;
	27	}
	28
19	29	@Override
20	30	public boolean canReuse(IInformationControl control) {
21		return false;
	31	return control instanceof MarkerInformationControl;
22	32	}
23	33
24	34	@Override
25	35	public boolean canReplace(IInformationControlCreator creator) {
26		return false;
	36	return creator instanceof MarkerHoverControlCreator;
27	37	}
28	38
29	39	@Override
30	40	public IInformationControl createInformationControl(Shell parent) {
31		return new MarkerInformationControl(parent,this);
	41	return new MarkerInformationControl(parent, showAffordanceString);
32	42	}
33	43
34	44	}

+31

-24

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/markers/MarkerInformationControl.java less more

10	10	package org.eclipse.ui.internal.genericeditor.markers;
11	11
12	12	import java.util.Collection;
	13	import java.util.LinkedHashMap;
13	14	import java.util.List;
14	15
15	16	import org.eclipse.core.resources.IMarker;

18	19	import org.eclipse.core.runtime.Status;
19	20	import org.eclipse.core.runtime.jobs.Job;
20	21	import org.eclipse.jface.text.AbstractInformationControl;
21		import org.eclipse.jface.text.AbstractReusableInformationControlCreator;
22	22	import org.eclipse.jface.text.IInformationControl;
23	23	import org.eclipse.jface.text.IInformationControlCreator;
24	24	import org.eclipse.jface.text.IInformationControlExtension;

45	45
46	46	public class MarkerInformationControl extends AbstractInformationControl implements IInformationControl, IInformationControlExtension, IInformationControlExtension2 {
47	47
48		private IInformationControlCreator creator;
	48	private final LinkedHashMap<IMarker, Composite> composites = new LinkedHashMap<>();
49	49
50		public MarkerInformationControl(Shell parentShell, IInformationControlCreator creator) {
51		super(parentShell, EditorsUI.getTooltipAffordanceString());
52		this.creator = creator;
	50	public MarkerInformationControl(Shell parentShell, boolean showAffordanceString) {
	51	super(parentShell, showAffordanceString ? EditorsUI.getTooltipAffordanceString() : null);
53	52	create();
54	53	}
55	54

60	59	public boolean hasContents() {
61	60	return this.markers != null && !this.markers.isEmpty();
62	61	}
63
	62
64	63	@Override
65	64	protected void createContent(Composite parent) {
66	65	parent.setLayout(new RowLayout(SWT.VERTICAL));

83	82	@SuppressWarnings("unchecked")
84	83	@Override
85	84	public void setInput(Object input) {
	85	this.composites.values().forEach(Composite::dispose);
86	86	this.markers = (List<IMarker>)input;
87	87	for (IMarker marker : this.markers) {
88	88	Composite markerComposite = new Composite(parent, SWT.NONE);
	89	this.composites.put(marker, markerComposite);
89	90	GridLayout gridLayout = new GridLayout(1, false);
90	91	gridLayout.verticalSpacing = 0;
	92	gridLayout.horizontalSpacing = 0;
	93	gridLayout.marginHeight = 0;
	94	gridLayout.marginWidth = 0;
91	95	markerComposite.setLayout(gridLayout);
92	96	Composite markerLine = new Composite(markerComposite, SWT.NONE);
93		markerLine.setLayout(new RowLayout());
94		Label markerImage = new Label(markerLine, SWT.NONE);
95		markerImage.setImage(getImage(marker));
	97	RowLayout rowLayout = new RowLayout();
	98	rowLayout.marginTop = 0;
	99	rowLayout.marginBottom = 0;
	100	rowLayout.marginLeft = 0;
	101	rowLayout.marginRight = 0;
	102	markerLine.setLayout(rowLayout);
	103	IMarkerResolution[] resolutions = IDE.getMarkerHelpRegistry().getResolutions(marker);
	104	if(resolutions.length > 0) {
	105	Label markerImage = new Label(markerLine, SWT.NONE);
	106	markerImage.setImage(getImage(marker));
	107	}
96	108	Label markerLabel = new Label(markerLine, SWT.NONE);
97	109	markerLabel.setText(marker.getAttribute(IMarker.MESSAGE, "missing message")); //$NON-NLS-1$
98		for (IMarkerResolution resolution : IDE.getMarkerHelpRegistry().getResolutions(marker)) {
	110	for (IMarkerResolution resolution : resolutions) {
99	111	Composite resolutionComposite = new Composite(markerComposite, SWT.NONE);
100	112	GridData layoutData = new GridData();
101	113	layoutData.horizontalIndent = 10;
102	114	resolutionComposite.setLayoutData(layoutData);
103		RowLayout rowLayout = new RowLayout();
104		rowLayout.marginBottom = 0;
105		resolutionComposite.setLayout(rowLayout);
	115	RowLayout resolutionRowLayout = new RowLayout();
	116	resolutionRowLayout.marginBottom = 0;
	117	resolutionComposite.setLayout(resolutionRowLayout);
106	118	Label resolutionImage = new Label(resolutionComposite, SWT.NONE);
107	119	// TODO: try to retrieve icon from QuickFix command
108		Image resolutionPic = null;
	120	Image resolutionPic = null;
109	121	if (resolution instanceof IMarkerResolution2) {
110	122	resolutionPic = ((IMarkerResolution2) resolution).getImage();
111	123	}

134	146	});
135	147	}
136	148	}
137		parent.pack(true);
	149	parent.layout(true);
138	150	}
139
	151
140	152	@Override
141	153	public IInformationControlCreator getInformationPresenterControlCreator() {
142		return new AbstractReusableInformationControlCreator() {
143		@Override
144		protected IInformationControl doCreateInformationControl(Shell parent) {
145		return creator.createInformationControl(parent);
146		}
147		};
	154	return new MarkerHoverControlCreator(false);
148	155	}
149
	156
150	157	@Override
151	158	public Point computeSizeHint() {
152	159	getShell().pack();
153	160	return getShell().getSize();
154	161	}
155
	162
156	163	}⏎

+11

-0

org.eclipse.ui.genericeditor/src/org/eclipse/ui/internal/genericeditor/messages.properties less more

	0	###############################################################################
	1	# Copyright (c) 2018 Red Hat Inc. and others.
	2	# All rights reserved. This program and the accompanying materials
	3	# are made available under the terms of the Eclipse Public License v1.0
	4	# which accompanies this distribution, and is available at
	5	# http://www.eclipse.org/legal/epl-v10.html
	6	#
	7	# Contributors:
	8	# Alexander Kurtakov (Red Hat Inc.) - initial API and implementation
	9	###############################################################################
	10	DefaultWordHighlightStrategy_OccurrencesOf=Occurrence of ''{0}''

+6

-2

org.eclipse.ui.genericeditor.examples/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: Examples for Generic Editor
3	3	Bundle-SymbolicName: org.eclipse.ui.genericeditor.examples;singleton:=true
4		Bundle-Version: 1.0.0.qualifier
	4	Bundle-Version: 1.1.0.qualifier
5	5	Bundle-Vendor: Eclipse.org
6	6	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
7	7	Require-Bundle: org.eclipse.ui.genericeditor;bundle-version="1.0.0",

10	10	org.eclipse.core.resources;bundle-version="3.11.0",
11	11	org.eclipse.ui;bundle-version="3.108.0",
12	12	org.eclipse.core.runtime;bundle-version="3.11.0",
13		org.eclipse.ui.workbench.texteditor;bundle-version="3.10.100"
	13	org.eclipse.ui.workbench.texteditor;bundle-version="3.10.100",
	14	org.eclipse.e4.core.commands;bundle-version="0.12.100",
	15	org.eclipse.ui.ide
	16	Export-Package: org.eclipse.ui.genericeditor.examples.dotproject
	17	Automatic-Module-Name: org.eclipse.ui.genericeditor.examples

+5

-0

org.eclipse.ui.genericeditor.examples/Readme.md less more

	0	== Example project demonstrating contributing to the Generic Editor for ".project" files
	1
	2	This is an example of a usable and feature rich editor for .project files which contributes to the Generic Editor proposal.
	3
	4	To test this plug-in open a .project file with the generic editor, you may have to remove the filter in the Project Explorer / Package explorer for . files.⏎

+1

-0

org.eclipse.ui.genericeditor.examples/forceQualifierUpdate.txt less more

0

Bug 521182 - [compiler] method reference on null object should throw NPE at runtime (JLS compliance)⏎

+65

-3

org.eclipse.ui.genericeditor.examples/plugin.xml less more

0	0	<?xml version="1.0" encoding="UTF-8"?>
1	1	<?eclipse version="3.4"?>
2	2	<!-- ====================================================================== -->
3		<!-- Copyright (c) 2016 Red Hat Inc. and others. -->
	3	<!-- Copyright (c) 2016, 2017 Red Hat Inc. and others. -->
4	4	<!-- All rights reserved. This program and the accompanying materials -->
5	5	<!-- are made available under the terms of the Eclipse Public License v1.0 -->
6	6	<!-- which accompanies this distribution, and is available at -->

8	8	<!-- -->
9	9	<!-- Contributors: -->
10	10	<!-- Sopot Cela & Mickael Istria (Red Hat Inc). -initial implementation -->
	11	<!-- Lucas Bullen (Red Hat Inc.) - Bug 508829 custom reconciler support -->
	12	<!-- - Bug 521382 default highlighter -->
	13	<!-- Simon Scholz <simon.scholz@vogella.com> - Bug 527834 -->
11	14	<!-- ====================================================================== -->
12	15	<plugin>
13	16	<extension

43	46	</presentationReconciler>
44	47	</extension>
45	48	<extension
	49	point="org.eclipse.ui.genericeditor.reconcilers">
	50	<reconciler
	51	class="org.eclipse.ui.genericeditor.examples.dotproject.FoldingReconciler"
	52	contentType="org.eclipse.ui.genericeditor.examples.dotproject">
	53	</reconciler>
	54	<reconciler
	55	class="org.eclipse.ui.genericeditor.examples.dotproject.BracketMatchingReconciler"
	56	contentType="org.eclipse.ui.genericeditor.examples.dotproject">
	57	</reconciler>
	58	</extension>
	59	<extension
46	60	point="org.eclipse.ui.editors">
47	61	<editorContentTypeBinding
48	62	contentTypeId="org.eclipse.ui.genericeditor.examples.dotproject"

56	70	contentTypeId="org.eclipse.ui.genericeditor.examples.dotproject">
57	71	</participant>
58	72	</extension>
59
60		</plugin>
	73	<extension
	74	point="org.eclipse.ui.genericeditor.autoEditStrategies">
	75	<autoEditStrategy
	76	class="org.eclipse.ui.genericeditor.examples.dotproject.TagAutoEditStrategy"
	77	contentType="org.eclipse.ui.genericeditor.examples.dotproject">
	78	</autoEditStrategy>
	79	</extension>
	80	<extension
	81	point="org.eclipse.ui.genericeditor.highlightReconcilers">
	82	<highlightReconciler
	83	class="org.eclipse.ui.genericeditor.examples.dotproject.HighlightReconciler"
	84	contentType="org.eclipse.ui.genericeditor.examples.dotproject">
	85	</highlightReconciler>
	86	</extension>
	87	<extension
	88	point="org.eclipse.ui.workbench.texteditor.hyperlinkDetectors">
	89	<hyperlinkDetector
	90	activate="true"
	91	class="org.eclipse.ui.genericeditor.examples.dotproject.hyperlink.ProjectHyperlinkDetector"
	92	id="org.eclipse.ui.genericeditor.examples.hyperlinkDetector"
	93	name="Project Settings Hyperlink Detector"
	94	targetId="org.eclipse.ui.genericeditor.GenericEditor">
	95	</hyperlinkDetector>
	96	</extension>
	97	<!-- ================== CodeMining support for .project ================== -->
	98	<!-- 1) register CodeMining provider with extension point -->
	99	<extension
	100	point="org.eclipse.ui.workbench.texteditor.codeMiningProviders">
	101	<codeMiningProvider
	102	class="org.eclipse.ui.genericeditor.examples.dotproject.codemining.ProjectReferencesCodeMiningProvider"
	103	id="org.eclipse.ui.genericeditor.examples.dotproject.codemining.references"
	104	label="Project references">
	105	<enabledWhen>
	106	<with variable="editorInput">
	107	<adapt type="org.eclipse.core.resources.IFile">
	108	<test property="org.eclipse.core.resources.contentTypeId" value="org.eclipse.ui.genericeditor.examples.dotproject" />
	109	</adapt>
	110	</with>
	111	</enabledWhen>
	112	</codeMiningProvider>
	113	</extension>
	114	<!-- 2) update CodeMining provider with a reconciler -->
	115	<extension
	116	point="org.eclipse.ui.genericeditor.reconcilers">
	117	<reconciler
	118	class="org.eclipse.jface.text.codemining.CodeMiningReconciler"
	119	contentType="org.eclipse.ui.genericeditor.examples.dotproject">
	120	</reconciler>
	121	</extension>
	122	</plugin>⏎

+2

-2

org.eclipse.ui.genericeditor.examples/pom.xml less more

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<groupId>org.eclipse.ui</groupId>
19	19	<artifactId>org.eclipse.ui.genericeditor.examples</artifactId>
20		<version>1.0.0-SNAPSHOT</version>
	20	<version>1.1.0-SNAPSHOT</version>
21	21	<packaging>eclipse-plugin</packaging>
22	22	</project>

+5

-7

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/BlueTagsPresentationReconciler.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others
	1	* Copyright (c) 2016, 2017 Red Hat Inc. and others
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

9	9	*******************************************************************************/
10	10	package org.eclipse.ui.genericeditor.examples.dotproject;
11	11
12		import org.eclipse.swt.graphics.Color;
13		import org.eclipse.swt.graphics.RGB;
14		import org.eclipse.swt.widgets.Display;
15
16	12	import org.eclipse.jface.text.IDocument;
17	13	import org.eclipse.jface.text.TextAttribute;
18	14	import org.eclipse.jface.text.presentation.PresentationReconciler;

21	17	import org.eclipse.jface.text.rules.RuleBasedScanner;
22	18	import org.eclipse.jface.text.rules.SingleLineRule;
23	19	import org.eclipse.jface.text.rules.Token;
	20	import org.eclipse.swt.SWT;
	21	import org.eclipse.swt.widgets.Display;
24	22
25	23	public class BlueTagsPresentationReconciler extends PresentationReconciler {
26	24
27		private final TextAttribute tagAttribute = new TextAttribute(new Color(Display.getCurrent(), new RGB(0,0, 255)));
28		private final TextAttribute headerAttribute = new TextAttribute(new Color(Display.getCurrent(), new RGB(128,128,128)));
	25	private final TextAttribute tagAttribute = new TextAttribute(Display.getCurrent().getSystemColor(SWT.COLOR_BLUE));
	26	private final TextAttribute headerAttribute = new TextAttribute(Display.getCurrent().getSystemColor(SWT.COLOR_DARK_GRAY));
29	27
30	28	public BlueTagsPresentationReconciler() {
31	29	RuleBasedScanner scanner= new RuleBasedScanner();

+91

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/BracketMatchingReconciler.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.examples.dotproject;
	11
	12	import org.eclipse.jface.text.BadLocationException;
	13	import org.eclipse.jface.text.IDocument;
	14	import org.eclipse.jface.text.IRegion;
	15	import org.eclipse.jface.text.ITextViewer;
	16	import org.eclipse.jface.text.ITextViewerExtension2;
	17	import org.eclipse.jface.text.Region;
	18	import org.eclipse.jface.text.reconciler.IReconciler;
	19	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	20	import org.eclipse.jface.text.source.ICharacterPairMatcher;
	21	import org.eclipse.jface.text.source.MatchingCharacterPainter;
	22	import org.eclipse.jface.text.source.SourceViewer;
	23	import org.eclipse.swt.graphics.Color;
	24	import org.eclipse.swt.graphics.RGBA;
	25	import org.eclipse.swt.widgets.Display;
	26
	27	public class BracketMatchingReconciler implements IReconciler{
	28	private RGBA fBoxingRGB = new RGBA(155, 155, 155, 50);
	29	private MatchingCharacterPainter fMatchingCharacterPainter;
	30	private SourceViewer fSourceViewer;
	31	private ICharacterPairMatcher fCharacterPairMatcher = new ICharacterPairMatcher() {
	32	@Override
	33	public IRegion match(IDocument document, int offset){
	34	try {
	35	String before = document.get(0, offset);
	36	String after = document.get(offset, document.getLength() - offset);
	37	int closingIndex = after.indexOf('>');
	38	int openingIndex = before.lastIndexOf('<');
	39	int previousClosingIndex = after.indexOf('<');
	40	int previousOpeningIndex = before.lastIndexOf('>');
	41	if((previousClosingIndex != -1 && closingIndex > previousClosingIndex)
	42	\|\| (previousOpeningIndex != -1 && openingIndex < previousOpeningIndex)) {
	43	return null;
	44	}
	45	return new Region(openingIndex, offset - openingIndex + closingIndex + 1);
	46	} catch (BadLocationException e) {
	47	return null;
	48	}
	49	}
	50
	51	@Override
	52	public int getAnchor() {
	53	return ICharacterPairMatcher.RIGHT;
	54	}
	55
	56	@Override
	57	public void dispose() {
	58	if(fMatchingCharacterPainter != null) {
	59	fMatchingCharacterPainter.dispose();
	60	}
	61	}
	62
	63	@Override
	64	public void clear() {
	65	// No memory implemented
	66	}
	67	};
	68
	69	@Override
	70	public void install(ITextViewer textViewer) {
	71	if (textViewer instanceof ITextViewerExtension2 && textViewer instanceof SourceViewer) {
	72	fSourceViewer = (SourceViewer)textViewer;
	73	fMatchingCharacterPainter = new MatchingCharacterPainter(fSourceViewer, fCharacterPairMatcher);
	74	fMatchingCharacterPainter.setColor(new Color (Display.getCurrent(), fBoxingRGB));
	75	fMatchingCharacterPainter.setHighlightCharacterAtCaretLocation(true);
	76	fMatchingCharacterPainter.setHighlightEnclosingPeerCharacters(true);
	77	fSourceViewer.addPainter(fMatchingCharacterPainter);
	78	}
	79	}
	80
	81	@Override
	82	public void uninstall() {
	83	fSourceViewer.removePainter(fMatchingCharacterPainter);
	84	}
	85
	86	@Override
	87	public IReconcilingStrategy getReconcilingStrategy(String contentType) {
	88	return null;
	89	}
	90	}

+33

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/FoldingReconciler.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.examples.dotproject;
	11
	12	import org.eclipse.jface.text.IDocument;
	13	import org.eclipse.jface.text.ITextViewer;
	14	import org.eclipse.jface.text.reconciler.Reconciler;
	15	import org.eclipse.jface.text.source.projection.ProjectionViewer;
	16
	17	public class FoldingReconciler extends Reconciler {
	18
	19	private FoldingStrategy fStrategy;
	20
	21	public FoldingReconciler() {
	22	fStrategy = new FoldingStrategy();
	23	this.setReconcilingStrategy(fStrategy, IDocument.DEFAULT_CONTENT_TYPE);
	24	}
	25
	26	@Override
	27	public void install(ITextViewer textViewer) {
	28	super.install(textViewer);
	29	ProjectionViewer pViewer =(ProjectionViewer)textViewer;
	30	fStrategy.setProjectionViewer(pViewer);
	31	}
	32	}⏎

+157

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/FoldingStrategy.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.examples.dotproject;
	11
	12	import java.util.ArrayList;
	13	import java.util.HashMap;
	14	import java.util.List;
	15	import java.util.Map;
	16
	17	import org.eclipse.core.runtime.IProgressMonitor;
	18	import org.eclipse.jface.text.BadLocationException;
	19	import org.eclipse.jface.text.IDocument;
	20	import org.eclipse.jface.text.IRegion;
	21	import org.eclipse.jface.text.Position;
	22	import org.eclipse.jface.text.reconciler.DirtyRegion;
	23	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	24	import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
	25	import org.eclipse.jface.text.source.Annotation;
	26	import org.eclipse.jface.text.source.projection.ProjectionAnnotation;
	27	import org.eclipse.jface.text.source.projection.ProjectionViewer;
	28
	29	public class FoldingStrategy implements IReconcilingStrategy, IReconcilingStrategyExtension {
	30
	31	private IDocument document;
	32	private String oldDocument;
	33	private ProjectionViewer projectionViewer;
	34	private List<Annotation> oldAnnotations = new ArrayList<>();
	35	private List<Position> oldPositions = new ArrayList<>();
	36
	37	@Override
	38	public void setDocument(IDocument document) {
	39	this.document = document;
	40	}
	41
	42	public void setProjectionViewer(ProjectionViewer projectionViewer) {
	43	this.projectionViewer = projectionViewer;
	44	}
	45
	46	@Override
	47	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	48	initialReconcile();
	49	}
	50
	51	@Override
	52	public void reconcile(IRegion partition) {
	53	initialReconcile();
	54	}
	55
	56	@Override
	57	public void initialReconcile() {
	58	if(document.get().equals(oldDocument)) return;
	59	oldDocument = document.get();
	60
	61	List<Position> positions = getNewPositionsOfAnnotations();
	62
	63	List<Position> positionsToRemove = new ArrayList<>();
	64	List<Annotation> annotationToRemove = new ArrayList<>();
	65
	66	for (Position position : oldPositions) {
	67	if(!positions.contains(position)) {
	68	projectionViewer.getProjectionAnnotationModel().removeAnnotation(oldAnnotations.get(oldPositions.indexOf(position)));
	69	positionsToRemove.add(position);
	70	annotationToRemove.add(oldAnnotations.get(oldPositions.indexOf(position)));
	71	}else {
	72	positions.remove(position);
	73	}
	74	}
	75	oldPositions.removeAll(positionsToRemove);
	76	oldAnnotations.removeAll(annotationToRemove);
	77
	78	for (Position position : positions) {
	79	Annotation annotation = new ProjectionAnnotation();
	80	projectionViewer.getProjectionAnnotationModel().addAnnotation(annotation, position);
	81	oldPositions.add(position);
	82	oldAnnotations.add(annotation);
	83	}
	84	}
	85
	86	private static enum SearchingFor {
	87	START_OF_TAG, START_OF_WORD, END_OF_WORD, END_OF_LINE
	88	}
	89
	90	private List<Position> getNewPositionsOfAnnotations(){
	91	List<Position> positions = new ArrayList<>();
	92	Map<String, Integer> startOfAnnotation = new HashMap<>();
	93	SearchingFor searchingFor = SearchingFor.START_OF_TAG;
	94
	95	int characters = document.getLength();
	96	int currentCharIndex = 0;
	97
	98	int wordStartIndex = 0;
	99	int sectionStartIndex = 0;
	100	String word = "";
	101
	102	try {
	103	while (currentCharIndex < characters) {
	104	char currentChar = document.getChar(currentCharIndex);
	105	switch (searchingFor) {
	106	case START_OF_TAG:
	107	if(currentChar == '<') {
	108	char nextChar = document.getChar(currentCharIndex+1);
	109	if(nextChar != '?') {
	110	sectionStartIndex = currentCharIndex;
	111	searchingFor = SearchingFor.START_OF_WORD;
	112	}
	113	}
	114	break;
	115	case START_OF_WORD:
	116	if(Character.isLetter(currentChar)) {
	117	wordStartIndex = currentCharIndex;
	118	searchingFor = SearchingFor.END_OF_WORD;
	119	}
	120	break;
	121	case END_OF_WORD:
	122	if(!Character.isLetter(currentChar)) {
	123	word = document.get(wordStartIndex, currentCharIndex - wordStartIndex);
	124	if(startOfAnnotation.containsKey(word)) {
	125	searchingFor = SearchingFor.END_OF_LINE;
	126	}else {
	127	startOfAnnotation.put(word, sectionStartIndex);
	128	searchingFor = SearchingFor.START_OF_TAG;
	129	}
	130	}
	131	break;
	132	case END_OF_LINE:
	133	if(currentChar == '\n') {
	134	int start = startOfAnnotation.get(word);
	135	if(document.getLineOfOffset(start) != document.getLineOfOffset(currentCharIndex)) {
	136	positions.add(new Position(start,currentCharIndex + 1 - start));
	137	}
	138	startOfAnnotation.remove(word);
	139	searchingFor = SearchingFor.START_OF_TAG;
	140	}
	141	break;
	142	}
	143	currentCharIndex++;
	144	}
	145	} catch (BadLocationException e) {
	146	// skip the remainder of file due to error
	147	}
	148	return positions;
	149	}
	150
	151	@Override
	152	public void setProgressMonitor(IProgressMonitor monitor) {
	153	// no progress monitor used
	154	}
	155
	156	}⏎

+37

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/HighlightReconciler.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Lucas Bullen (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.examples.dotproject;
	11
	12	import org.eclipse.jface.text.IDocument;
	13	import org.eclipse.jface.text.ITextViewer;
	14	import org.eclipse.jface.text.reconciler.Reconciler;
	15
	16	public class HighlightReconciler extends Reconciler {
	17
	18	private HighlightStrategy fStrategy;
	19
	20	public HighlightReconciler() {
	21	fStrategy = new HighlightStrategy();
	22	this.setReconcilingStrategy(fStrategy, IDocument.DEFAULT_CONTENT_TYPE);
	23	}
	24
	25	@Override
	26	public void install(ITextViewer textViewer) {
	27	super.install(textViewer);
	28	fStrategy.install(textViewer);
	29	}
	30
	31	@Override
	32	public void uninstall() {
	33	super.uninstall();
	34	fStrategy.uninstall();
	35	}
	36	}⏎

+209

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/HighlightStrategy.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Lucas Bullen (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.examples.dotproject;
	11
	12	import java.util.HashMap;
	13	import java.util.Iterator;
	14	import java.util.Map;
	15	import java.util.Map.Entry;
	16	import java.util.regex.Matcher;
	17	import java.util.regex.Pattern;
	18
	19	import org.eclipse.core.runtime.IProgressMonitor;
	20	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
	21	import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
	22	import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;
	23	import org.eclipse.core.runtime.preferences.InstanceScope;
	24	import org.eclipse.jface.text.IDocument;
	25	import org.eclipse.jface.text.IRegion;
	26	import org.eclipse.jface.text.ISynchronizable;
	27	import org.eclipse.jface.text.ITextViewer;
	28	import org.eclipse.jface.text.ITextViewerExtension5;
	29	import org.eclipse.jface.text.Position;
	30	import org.eclipse.jface.text.reconciler.DirtyRegion;
	31	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	32	import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
	33	import org.eclipse.jface.text.source.Annotation;
	34	import org.eclipse.jface.text.source.IAnnotationModel;
	35	import org.eclipse.jface.text.source.IAnnotationModelExtension;
	36	import org.eclipse.jface.text.source.ISourceViewer;
	37	import org.eclipse.swt.custom.CaretEvent;
	38	import org.eclipse.swt.custom.CaretListener;
	39
	40	/**
	41	*
	42	* This Reconciler Strategy is an example for how to override the default highlight strategy.
	43	* It will highlight closing and opening tag names that match the current word the user is on.
	44	*
	45	*/
	46	public class HighlightStrategy implements IReconcilingStrategy, IReconcilingStrategyExtension, CaretListener, IPreferenceChangeListener {
	47
	48	private static final String ANNOTATION_TYPE = "org.eclipse.ui.genericeditor.text"; //$NON-NLS-1$
	49	public static final String TOGGLE_HIGHLIGHT_PREFERENCE = "org.eclipse.ui.genericeditor.togglehighlight"; //$NON-NLS-1$
	50	public static final String GENERIC_EDITOR_BUNDLE_ID = "org.eclipse.ui.genericeditor"; //$NON-NLS-1$
	51
	52	private boolean enabled;
	53	private ISourceViewer sourceViewer;
	54	private IDocument document;
	55
	56	private static final String TAG_NAME_REGEX = "<\\/?\\s*([a-zA-Z]+)"; //$NON-NLS-1$
	57	private static final Pattern TAG_NAME_PATTERN = Pattern.compile(TAG_NAME_REGEX);
	58
	59	private Annotation[] fOccurrenceAnnotations = null;
	60
	61	private void applyHighlights(int offset) {
	62	if (sourceViewer == null \|\| !enabled) {
	63	return;
	64	}
	65	String text = document.get();
	66	offset = ((ITextViewerExtension5)sourceViewer).widgetOffset2ModelOffset(offset);
	67
	68	int wordStartOffset = Math.max(text.lastIndexOf('/',offset),text.lastIndexOf('<',offset))+1;
	69	int wordEndOffset = findEndingOffset(text, offset);
	70	if(wordEndOffset <= wordStartOffset \|\| wordEndOffset == -1 \|\| wordStartOffset == -1)
	71	return;
	72	String word = text.substring(wordStartOffset, wordEndOffset);
	73	if(word.indexOf('>') != -1 \|\| word.indexOf('<') != -1) {
	74	removeOccurrenceAnnotations();
	75	return;
	76	}
	77
	78	Matcher m = TAG_NAME_PATTERN.matcher(text);
	79	Map<Annotation, Position> annotationMap = new HashMap<>();
	80	while(m.find()) {
	81	if(m.group(1).equals(word)) {
	82	annotationMap.put(new Annotation(ANNOTATION_TYPE, false, null),
	83	new Position(m.start(1), m.end(1) - m.start(1)));
	84	}
	85	}
	86
	87	if(annotationMap.size() < 2) {
	88	removeOccurrenceAnnotations();
	89	return;
	90	}
	91
	92	IAnnotationModel annotationModel = sourceViewer.getAnnotationModel();
	93	synchronized (getLockObject(annotationModel)) {
	94	if (annotationModel instanceof IAnnotationModelExtension) {
	95	((IAnnotationModelExtension) annotationModel).replaceAnnotations(fOccurrenceAnnotations, annotationMap);
	96	} else {
	97	removeOccurrenceAnnotations();
	98	Iterator<Entry<Annotation, Position>> iter = annotationMap.entrySet().iterator();
	99	while (iter.hasNext()) {
	100	Entry<Annotation, Position> mapEntry = iter.next();
	101	annotationModel.addAnnotation(mapEntry.getKey(), mapEntry.getValue());
	102	}
	103	}
	104	fOccurrenceAnnotations = annotationMap.keySet().toArray(new Annotation[annotationMap.keySet().size()]);
	105	}
	106	}
	107
	108	private static int findEndingOffset(String text, int offset) {
	109	String substring = text.substring(offset);
	110	String[] split = substring.split("[^a-zA-Z0-9]+");//$NON-NLS-1$
	111	if(split.length == 0) {
	112	return -1;
	113	}
	114	return offset + split[0].length();
	115	}
	116
	117	public void install(ITextViewer viewer) {
	118	if (!(viewer instanceof ISourceViewer)) {
	119	return;
	120	}
	121	IEclipsePreferences preferences = InstanceScope.INSTANCE.getNode(GENERIC_EDITOR_BUNDLE_ID);
	122	preferences.addPreferenceChangeListener(this);
	123	this.enabled = preferences.getBoolean(TOGGLE_HIGHLIGHT_PREFERENCE, true);
	124	this.sourceViewer = (ISourceViewer) viewer;
	125	this.sourceViewer.getTextWidget().addCaretListener(this);
	126	}
	127
	128	public void uninstall() {
	129	if (sourceViewer != null) {
	130	sourceViewer.getTextWidget().removeCaretListener(this);
	131	}
	132	IEclipsePreferences preferences = InstanceScope.INSTANCE.getNode(GENERIC_EDITOR_BUNDLE_ID);
	133	preferences.removePreferenceChangeListener(this);
	134	}
	135
	136	@Override
	137	public void preferenceChange(PreferenceChangeEvent event) {
	138	if (event.getKey().equals(TOGGLE_HIGHLIGHT_PREFERENCE)) {
	139	this.enabled = Boolean.parseBoolean(event.getNewValue().toString());
	140	if (enabled) {
	141	initialReconcile();
	142	} else {
	143	removeOccurrenceAnnotations();
	144	}
	145	}
	146	}
	147
	148	@Override
	149	public void caretMoved(CaretEvent event) {
	150	applyHighlights(event.caretOffset);
	151	}
	152
	153	@Override
	154	public void initialReconcile() {
	155	if (sourceViewer != null) {
	156	sourceViewer.getTextWidget().getDisplay().asyncExec(() -> {
	157	if (sourceViewer != null && sourceViewer.getTextWidget() != null) {
	158	applyHighlights(sourceViewer.getTextWidget().getCaretOffset());
	159	}
	160	});
	161	}
	162	}
	163
	164	void removeOccurrenceAnnotations() {
	165	IAnnotationModel annotationModel = sourceViewer.getAnnotationModel();
	166	if (annotationModel == null \|\| fOccurrenceAnnotations == null)
	167	return;
	168
	169	synchronized (getLockObject(annotationModel)) {
	170	if (annotationModel instanceof IAnnotationModelExtension) {
	171	((IAnnotationModelExtension) annotationModel).replaceAnnotations(fOccurrenceAnnotations, null);
	172	} else {
	173	for (Annotation fOccurrenceAnnotation : fOccurrenceAnnotations)
	174	annotationModel.removeAnnotation(fOccurrenceAnnotation);
	175	}
	176	fOccurrenceAnnotations = null;
	177	}
	178	}
	179
	180	private static Object getLockObject(IAnnotationModel annotationModel) {
	181	if (annotationModel instanceof ISynchronizable) {
	182	Object lock = ((ISynchronizable) annotationModel).getLockObject();
	183	if (lock != null)
	184	return lock;
	185	}
	186	return annotationModel;
	187	}
	188
	189	@Override
	190	public void setDocument(IDocument document) {
	191	this.document = document;
	192	}
	193
	194	@Override
	195	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	196	// Do nothing
	197	}
	198
	199	@Override
	200	public void reconcile(IRegion partition) {
	201	// Do nothing
	202	}
	203
	204	@Override
	205	public void setProgressMonitor(IProgressMonitor monitor) {
	206	// Not used
	207	}
	208	}

+3

-2

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/NatureLabelHoverProvider.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others
	1	* Copyright (c) 2016, 2017 Red Hat Inc. and others
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

6	6	*
7	7	* Contributors:
8	8	* Mickael Istria, Sopot Cela (Red Hat Inc.)
	9	* Lucas Bullen (Red Hat Inc.) - [Bug 527071] Hover breaks with missing nature
9	10	*******************************************************************************/
10	11	package org.eclipse.ui.genericeditor.examples.dotproject;
11	12

38	39	if (natureDescriptors[i].getNatureId().equals(selection))
39	40	return natureDescriptors[i].getLabel();
40	41	}
41		return "";
	42	return null;
42	43	}
43	44
44	45	@Override

+4

-1

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/NaturesAndProjectsContentAssistProcessor.java less more

13	13	import org.eclipse.core.resources.IProjectNatureDescriptor;
14	14	import org.eclipse.core.resources.IWorkspace;
15	15	import org.eclipse.core.resources.ResourcesPlugin;
16
17	16	import org.eclipse.jface.text.ITextViewer;
18	17	import org.eclipse.jface.text.contentassist.CompletionProposal;
19	18	import org.eclipse.jface.text.contentassist.ICompletionProposal;

22	21	import org.eclipse.jface.text.contentassist.IContextInformationValidator;
23	22
24	23	public class NaturesAndProjectsContentAssistProcessor implements IContentAssistProcessor {
	24
	25	public NaturesAndProjectsContentAssistProcessor() {
	26	// TODO Auto-generated constructor stub
	27	}
25	28
26	29	@Override
27	30	public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {

+7

-1

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/SpellCheckDocumentListener.java less more

6	6	*
7	7	* Contributors:
8	8	* - Mickael Istria (Red Hat Inc.)
	9	* - Lucas Bullen (Red Hat Inc.) - avoid NPE for when TextFileBuffer does not exist
9	10	*******************************************************************************/
10	11	package org.eclipse.ui.genericeditor.examples.dotproject;
11	12

14	15	import java.util.Map;
15	16	import java.util.Set;
16	17
	18	import org.eclipse.core.filebuffers.ITextFileBuffer;
17	19	import org.eclipse.core.filebuffers.ITextFileBufferManager;
18	20	import org.eclipse.core.runtime.IProgressMonitor;
19	21	import org.eclipse.core.runtime.IStatus;

49	51	this.lastJob = new Job("Spellcheck") {
50	52	@Override
51	53	protected IStatus run(IProgressMonitor monitor) {
52		IAnnotationModel model = ITextFileBufferManager.DEFAULT.getTextFileBuffer(event.getDocument()).getAnnotationModel();
	54	ITextFileBuffer iTextFileBuffer = ITextFileBufferManager.DEFAULT.getTextFileBuffer(event.getDocument());
	55	if(iTextFileBuffer == null) {
	56	return Status.CANCEL_STATUS;
	57	}
	58	IAnnotationModel model = iTextFileBuffer.getAnnotationModel();
53	59	String text = event.getDocument().get();
54	60	int commentStart = text.indexOf("<comment>");
55	61	if (commentStart < 0) {

+43

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/TagAutoEditStrategy.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Rogue Wave Software Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Michał Niewrzał (Rogue Wave Software Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.examples.dotproject;
	11
	12	import org.eclipse.jface.text.BadLocationException;
	13	import org.eclipse.jface.text.DocumentCommand;
	14	import org.eclipse.jface.text.IAutoEditStrategy;
	15	import org.eclipse.jface.text.IDocument;
	16	import org.eclipse.jface.text.IRegion;
	17
	18	public class TagAutoEditStrategy implements IAutoEditStrategy {
	19
	20	public TagAutoEditStrategy() {
	21	// TODO Auto-generated constructor stub
	22	}
	23
	24	@Override
	25	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
	26	if (!">".equals(command.text)) { //$NON-NLS-1$
	27	return;
	28	}
	29	try {
	30	IRegion region = document.getLineInformationOfOffset(command.offset);
	31	String line = document.get(region.getOffset(), command.offset - region.getOffset());
	32	int index = line.lastIndexOf('<');
	33	if (index != -1 && (index != line.length() - 1) && line.charAt(index + 1) != '/') {
	34	String tag = line.substring(index + 1);
	35	command.text += "</" + tag + command.text; //$NON-NLS-1$
	36	}
	37	} catch (BadLocationException e) {
	38	e.printStackTrace();
	39	}
	40	}
	41
	42	}

+46

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/codemining/ProjectReferenceCodeMining.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide extension point for CodeMining - Bug 528419
	9	*/
	10	package org.eclipse.ui.genericeditor.examples.dotproject.codemining;
	11
	12	import java.util.concurrent.CompletableFuture;
	13
	14	import org.eclipse.core.resources.IProject;
	15	import org.eclipse.core.resources.ResourcesPlugin;
	16	import org.eclipse.core.runtime.IProgressMonitor;
	17	import org.eclipse.jface.text.BadLocationException;
	18	import org.eclipse.jface.text.IDocument;
	19	import org.eclipse.jface.text.ITextViewer;
	20	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
	21	import org.eclipse.jface.text.codemining.LineHeaderCodeMining;
	22
	23	/**
	24	* Project reference mining.
	25	*/
	26	public class ProjectReferenceCodeMining extends LineHeaderCodeMining {
	27
	28	private final String projectName;
	29
	30	public ProjectReferenceCodeMining(String projectName, int beforeLineNumber, IDocument document,
	31	ICodeMiningProvider provider) throws BadLocationException {
	32	super(beforeLineNumber, document, provider);
	33	this.projectName = projectName;
	34	}
	35
	36	@Override
	37	protected CompletableFuture<Void> doResolve(ITextViewer viewer, IProgressMonitor monitor) {
	38	return CompletableFuture.runAsync(() -> {
	39	IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
	40	int refCount = project != null ? project.getReferencingProjects().length : 0;
	41	super.setLabel(refCount + (refCount > 1 ? " references" : " reference"));
	42	});
	43	}
	44
	45	}

+75

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/codemining/ProjectReferencesCodeMiningProvider.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide extension point for CodeMining - Bug 528419
	9	*/
	10	package org.eclipse.ui.genericeditor.examples.dotproject.codemining;
	11
	12	import java.util.ArrayList;
	13	import java.util.List;
	14	import java.util.concurrent.CompletableFuture;
	15
	16	import org.eclipse.core.runtime.IProgressMonitor;
	17	import org.eclipse.jface.text.BadLocationException;
	18	import org.eclipse.jface.text.IDocument;
	19	import org.eclipse.jface.text.ITextViewer;
	20	import org.eclipse.jface.text.codemining.AbstractCodeMiningProvider;
	21	import org.eclipse.jface.text.codemining.ICodeMining;
	22
	23	/**
	24	* Project reference minings provider.
	25	*/
	26	public class ProjectReferencesCodeMiningProvider extends AbstractCodeMiningProvider {
	27
	28	@Override
	29	public CompletableFuture<List<? extends ICodeMining>> provideCodeMinings(ITextViewer viewer,
	30	IProgressMonitor monitor) {
	31	return CompletableFuture.supplyAsync(() -> {
	32	IDocument document = viewer.getDocument();
	33	List<ICodeMining> minings = new ArrayList<>();
	34	int lineCount = document.getNumberOfLines();
	35	for (int i = 0; i < lineCount; i++) {
	36	// check if request was canceled.
	37	monitor.isCanceled();
	38	String line = getLineText(document, i).trim();
	39	int startIndex = line.indexOf("<name>");
	40	if (startIndex != -1) {
	41	// It's the first name, we consider we are in <projectDescription></name>
	42	startIndex += "<name>".length();
	43	int endIndex = line.indexOf("</name>");
	44	if (endIndex > startIndex) {
	45	// Check if parent element is projectDescription
	46	String projectName = line.substring(startIndex, endIndex);
	47	if (projectName.length() > 0) {
	48	try {
	49	minings.add(new ProjectReferenceCodeMining(projectName, i, document, this));
	50	} catch (BadLocationException e) {
	51	e.printStackTrace();
	52	}
	53	}
	54	}
	55	// stop the compute of minings to avoid process other name like
	56	// <buildCommand><name>
	57	break;
	58	}
	59	}
	60	return minings;
	61	});
	62	}
	63
	64	private static String getLineText(IDocument document, int line) {
	65	try {
	66	int lo = document.getLineOffset(line);
	67	int ll = document.getLineLength(line);
	68	return document.get(lo, ll);
	69	} catch (Exception e) {
	70	e.printStackTrace();
	71	return null;
	72	}
	73	}
	74	}

+45

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/hyperlink/ProjectHyperlinkDetector.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 vogella GmbH and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Simon Scholz <simon.scholz@vogella.com> - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.examples.dotproject.hyperlink;
	11
	12	import org.eclipse.core.resources.IResource;
	13	import org.eclipse.jface.text.IRegion;
	14	import org.eclipse.jface.text.ITextViewer;
	15	import org.eclipse.jface.text.hyperlink.AbstractHyperlinkDetector;
	16	import org.eclipse.jface.text.hyperlink.IHyperlink;
	17	import org.eclipse.jface.text.hyperlink.URLHyperlink;
	18	import org.eclipse.osgi.util.TextProcessor;
	19	import org.eclipse.ui.internal.ide.dialogs.IDEResourceInfoUtils;
	20	import org.eclipse.ui.texteditor.ITextEditor;
	21
	22	@SuppressWarnings("restriction")
	23	public class ProjectHyperlinkDetector extends AbstractHyperlinkDetector {
	24
	25	@Override
	26	public IHyperlink[] detectHyperlinks(ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks) {
	27	ITextEditor textEditor = getAdapter(ITextEditor.class);
	28
	29	IResource resource = textEditor.getEditorInput().getAdapter(IResource.class);
	30
	31	String fileLocation = TextProcessor.process(IDEResourceInfoUtils.getLocationText(resource));
	32
	33	ShowInSystemExplorerHyperlink showInSystemExplorerHyperlink = new ShowInSystemExplorerHyperlink(fileLocation,
	34	region);
	35
	36	URLHyperlink fileUrlHyperlink = new URLHyperlink(region, fileLocation);
	37
	38	URLHyperlink projectFileHelpLink = new URLHyperlink(region,
	39	"https://help.eclipse.org/oxygen/index.jsp?topic=%2Forg.eclipse.platform.doc.isv%2Freference%2Fmisc%2Fproject_description_file.html");
	40
	41	return new IHyperlink[] { showInSystemExplorerHyperlink, fileUrlHyperlink, projectFileHelpLink };
	42	}
	43
	44	}

+65

-0

org.eclipse.ui.genericeditor.examples/src/org/eclipse/ui/genericeditor/examples/dotproject/hyperlink/ShowInSystemExplorerHyperlink.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 vogella GmbH and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Simon Scholz <simon.scholz@vogella.com> - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.examples.dotproject.hyperlink;
	11
	12	import java.util.Collections;
	13
	14	import org.eclipse.core.commands.Command;
	15	import org.eclipse.core.commands.ParameterizedCommand;
	16	import org.eclipse.e4.core.commands.ECommandService;
	17	import org.eclipse.e4.core.commands.EHandlerService;
	18	import org.eclipse.jface.text.IRegion;
	19	import org.eclipse.jface.text.hyperlink.IHyperlink;
	20	import org.eclipse.ui.PlatformUI;
	21	import org.eclipse.ui.internal.ide.handlers.ShowInSystemExplorerHandler;
	22
	23	@SuppressWarnings("restriction")
	24	public class ShowInSystemExplorerHyperlink implements IHyperlink {
	25
	26	private String fileLocation;
	27	private IRegion region;
	28
	29	public ShowInSystemExplorerHyperlink(String fileLocation, IRegion region) {
	30	this.fileLocation = fileLocation;
	31	this.region = region;
	32	}
	33
	34	@Override
	35	public IRegion getHyperlinkRegion() {
	36	return region;
	37	}
	38
	39	@Override
	40	public String getTypeLabel() {
	41	return null;
	42	}
	43
	44	@Override
	45	public String getHyperlinkText() {
	46	return "Show in System Explorer";
	47	}
	48
	49	@Override
	50	public void open() {
	51	ECommandService commandService = PlatformUI.getWorkbench().getService(ECommandService.class);
	52	EHandlerService handlerService = PlatformUI.getWorkbench().getService(EHandlerService.class);
	53
	54	Command command = commandService.getCommand(ShowInSystemExplorerHandler.ID);
	55	if (command.isDefined()) {
	56	ParameterizedCommand parameterizedCommand = commandService.createCommand(ShowInSystemExplorerHandler.ID,
	57	Collections.singletonMap(ShowInSystemExplorerHandler.RESOURCE_PATH_PARAMETER, fileLocation));
	58	if (handlerService.canExecute(parameterizedCommand)) {
	59	handlerService.executeHandler(parameterizedCommand);
	60	}
	61	}
	62	}
	63
	64	}

+4

-2

org.eclipse.ui.genericeditor.tests/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %Plugin.name
3	3	Bundle-SymbolicName: org.eclipse.ui.genericeditor.tests;singleton:=true
4		Bundle-Version: 1.0.0.qualifier
	4	Bundle-Version: 1.1.0.qualifier
5	5	Bundle-Vendor: %Plugin.providerName
6	6	Bundle-Localization: plugin
7	7	Export-Package: org.eclipse.ui.genericeditor.tests,

19	19	org.eclipse.jface.text.tests;bundle-version="3.11.100",
20	20	org.eclipse.text.tests;bundle-version="3.11.0",
21	21	org.eclipse.ui.workbench.texteditor.tests;bundle-version="3.11.100",
22		org.eclipse.ui.editors;bundle-version="3.11.0"
	22	org.eclipse.ui.editors;bundle-version="3.11.0",
	23	org.eclipse.core.expressions
23	24	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
24	25	Eclipse-BundleShape: dir
25	26	Bundle-ActivationPolicy: lazy
	27	Automatic-Module-Name: org.eclipse.ui.genericeditor.tests

+230

-40

org.eclipse.ui.genericeditor.tests/plugin.xml less more

0	0	<?xml version="1.0" encoding="UTF-8"?>
1	1	<?eclipse version="3.4"?>
2	2	<!-- ====================================================================== -->
3		<!-- Copyright (c) 2016 Red Hat Inc. and others. -->
	3	<!-- Copyright (c) 2016, 2017 Red Hat Inc. and others. -->
4	4	<!-- All rights reserved. This program and the accompanying materials -->
5	5	<!-- are made available under the terms of the Eclipse Public License v1.0 -->
6	6	<!-- which accompanies this distribution, and is available at -->

8	8	<!-- -->
9	9	<!-- Contributors: -->
10	10	<!-- Sopot Cela & Mickael Istria (Red Hat Inc). -initial implementation -->
	11	<!-- Lucas Bullen (Red Hat Inc.) - Bug 508829 custom reconciler support -->
	12	<!-- - Bug 521382 default highlighter -->
11	13	<!-- ====================================================================== -->
12	14	<plugin>
13		<extension
14		point="org.eclipse.ui.genericeditor.contentAssistProcessors">
	15	<extension
	16	point="org.eclipse.ui.genericeditor.contentAssistProcessors">
15	17	<contentAssistProcessor
16		class="org.eclipse.ui.genericeditor.tests.contributions.BarContentAssistProcessor"
17		contentType="org.eclipse.ui.genericeditor.tests.content-type">
	18	class="org.eclipse.ui.genericeditor.tests.contributions.BarContentAssistProcessor"
	19	contentType="org.eclipse.ui.genericeditor.tests.content-type">
18	20	</contentAssistProcessor>
19		<contentAssistProcessor
20		class="org.eclipse.ui.genericeditor.tests.contributions.LongRunningBarContentAssistProcessor"
21		contentType="org.eclipse.ui.genericeditor.tests.content-type">
22		</contentAssistProcessor>
23		</extension>
24		<extension
25		point="org.eclipse.ui.genericeditor.hoverProviders">
26		<hoverProvider
27		class="org.eclipse.ui.genericeditor.tests.contributions.MagicHoverProvider"
28		contentType="org.eclipse.ui.genericeditor.tests.content-type">
29		</hoverProvider>
30		</extension>
31		<extension
32		point="org.eclipse.ui.genericeditor.presentationReconcilers">
	21	<contentAssistProcessor
	22	class="org.eclipse.ui.genericeditor.tests.contributions.LongRunningBarContentAssistProcessor"
	23	contentType="org.eclipse.ui.genericeditor.tests.specialized-content-type">
	24	</contentAssistProcessor>
	25	<contentAssistProcessor
	26	class="org.eclipse.ui.genericeditor.tests.contributions.BarContentAssistProcessor"
	27	contentType="org.eclipse.ui.genericeditor.tests.enabled-when-content-type">
	28	<enabledWhen>
	29	<test
	30	forcePluginActivation="true"
	31	property="org.eclipse.ui.genericeditor.tests.contributions.enabled">
	32	</test>
	33	</enabledWhen>
	34	</contentAssistProcessor>
	35	</extension>
	36	<extension
	37	point="org.eclipse.ui.genericeditor.hoverProviders">
	38	<hoverProvider
	39	class="org.eclipse.ui.genericeditor.tests.contributions.AlrightyHoverProvider"
	40	contentType="org.eclipse.ui.genericeditor.tests.enabled-when-content-type">
	41	<enabledWhen>
	42	<test
	43	forcePluginActivation="true"
	44	property="org.eclipse.ui.genericeditor.tests.contributions.enabled">
	45	</test>
	46	</enabledWhen>
	47	</hoverProvider>
	48	<hoverProvider
	49	class="org.eclipse.ui.genericeditor.tests.contributions.AlrightyHoverProvider"
	50	contentType="org.eclipse.ui.genericeditor.tests.content-type">
	51	</hoverProvider>
	52	<hoverProvider
	53	class="org.eclipse.ui.genericeditor.tests.contributions.WorldHoverProvider"
	54	contentType="org.eclipse.ui.genericeditor.tests.content-type-bar">
	55	</hoverProvider>
	56	<hoverProvider
	57	class="org.eclipse.ui.genericeditor.tests.contributions.HelloHoverProvider"
	58	contentType="org.eclipse.ui.genericeditor.tests.specialized-content-type-bar">
	59	</hoverProvider>
	60	<hoverProvider
	61	class="org.eclipse.ui.genericeditor.tests.contributions.WorldHoverProvider"
	62	contentType="org.eclipse.ui.genericeditor.tests.enabled-when-content-type">
	63	<enabledWhen>
	64	<not>
	65	<test
	66	forcePluginActivation="true"
	67	property="org.eclipse.ui.genericeditor.tests.contributions.enabled">
	68	</test>
	69	</not>
	70	</enabledWhen>
	71	</hoverProvider>
	72	</extension>
	73	<extension
	74	point="org.eclipse.ui.genericeditor.reconcilers">
	75	<reconciler
	76	class="org.eclipse.ui.genericeditor.tests.contributions.TheReconcilerFirst"
	77	contentType="org.eclipse.ui.genericeditor.tests.content-type-bar">
	78	</reconciler>
	79	<reconciler
	80	class="org.eclipse.ui.genericeditor.tests.contributions.TheReconcilerSecond"
	81	contentType="org.eclipse.ui.genericeditor.tests.specialized-content-type-bar">
	82	</reconciler>
	83	<reconciler
	84	class="org.eclipse.ui.genericeditor.tests.contributions.TheReconcilerFirst"
	85	contentType="org.eclipse.ui.genericeditor.tests.content-type">
	86	</reconciler>
	87	<reconciler
	88	class="org.eclipse.ui.genericeditor.tests.contributions.TheReconcilerFirst"
	89	contentType="org.eclipse.ui.genericeditor.tests.enabled-when-content-type">
	90	<enabledWhen>
	91	<test
	92	forcePluginActivation="true"
	93	property="org.eclipse.ui.genericeditor.tests.contributions.enabled">
	94	</test>
	95	</enabledWhen>
	96	</reconciler>
	97	<reconciler
	98	class="org.eclipse.ui.genericeditor.tests.contributions.TheReconcilerSecond"
	99	contentType="org.eclipse.ui.genericeditor.tests.enabled-when-content-type">
	100	<enabledWhen>
	101	<not>
	102	<test
	103	forcePluginActivation="true"
	104	property="org.eclipse.ui.genericeditor.tests.contributions.enabled">
	105	</test>
	106	</not>
	107	</enabledWhen>
	108	</reconciler>
	109	</extension>
	110	<extension
	111	point="org.eclipse.ui.genericeditor.presentationReconcilers">
33	112	<presentationReconciler
34		class="org.eclipse.ui.genericeditor.tests.contributions.ThePresentationReconciler"
35		contentType="org.eclipse.ui.genericeditor.tests.content-type">
	113	class="org.eclipse.ui.genericeditor.tests.contributions.ThePresentationReconcilerBlue"
	114	contentType="org.eclipse.ui.genericeditor.tests.content-type">
36	115	</presentationReconciler>
37		</extension>
38		<extension
39		point="org.eclipse.ui.ide.markerResolution">
40		<markerResolutionGenerator
41		class="org.eclipse.ui.genericeditor.tests.contributions.MarkerResolutionGenerator"
42		markerType="org.eclipse.core.resources.problemmarker">
43		</markerResolutionGenerator>
44		</extension>
45		<extension
46		point="org.eclipse.core.contenttype.contentTypes">
47		<content-type
48		base-type="org.eclipse.core.runtime.text"
49		file-names="foo.txt"
50		id="org.eclipse.ui.genericeditor.tests.content-type"
51		name="Generic Editor Test content-type"
52		priority="normal">
53		</content-type>
54		</extension>
55
	116	<presentationReconciler
	117	class="org.eclipse.ui.genericeditor.tests.contributions.ThePresentationReconcilerGreen"
	118	contentType="org.eclipse.ui.genericeditor.tests.specialized-content-type">
	119	</presentationReconciler>
	120	<presentationReconciler
	121	class="org.eclipse.ui.genericeditor.tests.contributions.ThePresentationReconcilerRed"
	122	contentType="org.eclipse.ui.genericeditor.tests.sub-specialized-content-type">
	123	</presentationReconciler>
	124	<presentationReconciler
	125	class="org.eclipse.ui.genericeditor.tests.contributions.ThePresentationReconcilerBlue"
	126	contentType="org.eclipse.ui.genericeditor.tests.enabled-when-content-type">
	127	<enabledWhen>
	128	<test
	129	forcePluginActivation="true"
	130	property="org.eclipse.ui.genericeditor.tests.contributions.enabled">
	131	</test>
	132	</enabledWhen>
	133	</presentationReconciler>
	134	</extension>
	135	<extension
	136	point="org.eclipse.ui.ide.markerResolution">
	137	<markerResolutionGenerator
	138	class="org.eclipse.ui.genericeditor.tests.contributions.MarkerResolutionGenerator"
	139	markerType="org.eclipse.core.resources.problemmarker">
	140	</markerResolutionGenerator>
	141	</extension>
	142	<extension
	143	point="org.eclipse.core.contenttype.contentTypes">
	144	<content-type
	145	base-type="org.eclipse.core.runtime.text"
	146	file-names="foo.txt"
	147	id="org.eclipse.ui.genericeditor.tests.content-type"
	148	name="Generic Editor Test content-type"
	149	priority="normal">
	150	</content-type>
	151	<content-type
	152	base-type="org.eclipse.ui.genericeditor.tests.content-type"
	153	file-names="foo.txt"
	154	id="org.eclipse.ui.genericeditor.tests.specialized-content-type"
	155	name="Specialized Generic Editor content-type"
	156	priority="normal">
	157	</content-type>
	158	<content-type
	159	base-type="org.eclipse.ui.genericeditor.tests.specialized-content-type"
	160	file-names="foo.txt"
	161	id="org.eclipse.ui.genericeditor.tests.sub-specialized-content-type"
	162	name="Sub-Specialized Generic Editor content-type"
	163	priority="normal">
	164	</content-type>
	165	<content-type
	166	base-type="org.eclipse.ui.genericeditor.tests.content-type"
	167	file-names="foobar.txt"
	168	id="org.eclipse.ui.genericeditor.tests.specialized-content-type-foobartxt"
	169	name="Specialized Generic Editor content-type for 'foobar.txt'"
	170	priority="normal">
	171	</content-type>
	172	<content-type
	173	base-type="org.eclipse.core.runtime.text"
	174	file-names="bar.txt"
	175	id="org.eclipse.ui.genericeditor.tests.content-type-bar"
	176	name="Generic Editor Test content-type for 'bar.txt'"
	177	priority="normal">
	178	</content-type>
	179	<content-type
	180	base-type="org.eclipse.ui.genericeditor.tests.content-type-bar"
	181	file-names="bar.txt"
	182	id="org.eclipse.ui.genericeditor.tests.specialized-content-type-bar"
	183	name="Specialized Generic Editor content-type for 'bar.txt'"
	184	priority="normal">
	185	</content-type>
	186	<content-type
	187	base-type="org.eclipse.core.runtime.text"
	188	file-names="enabledWhen.txt"
	189	id="org.eclipse.ui.genericeditor.tests.enabled-when-content-type"
	190	name="enabledWhen content-type for 'enabledWhen.txt'"
	191	priority="normal">
	192	</content-type>
	193	</extension>
	194	<extension
	195	point="org.eclipse.ui.genericeditor.autoEditStrategies">
	196	<autoEditStrategy
	197	class="org.eclipse.ui.genericeditor.tests.contributions.TheAutoEditStrategyFirst"
	198	contentType="org.eclipse.ui.genericeditor.tests.content-type">
	199	</autoEditStrategy>
	200	<autoEditStrategy
	201	class="org.eclipse.ui.genericeditor.tests.contributions.TheAutoEditStrategySecond"
	202	contentType="org.eclipse.ui.genericeditor.tests.specialized-content-type">
	203	</autoEditStrategy>
	204	<autoEditStrategy
	205	class="org.eclipse.ui.genericeditor.tests.contributions.TheAutoEditStrategyThird"
	206	contentType="org.eclipse.ui.genericeditor.tests.sub-specialized-content-type">
	207	</autoEditStrategy>
	208	<autoEditStrategy
	209	class="org.eclipse.ui.genericeditor.tests.contributions.TheAutoEditStrategyFirst"
	210	contentType="org.eclipse.ui.genericeditor.tests.enabled-when-content-type">
	211	<enabledWhen>
	212	<test
	213	forcePluginActivation="true"
	214	property="org.eclipse.ui.genericeditor.tests.contributions.enabled">
	215	</test>
	216	</enabledWhen>
	217	</autoEditStrategy>
	218	</extension>
	219	<extension
	220	point="org.eclipse.ui.genericeditor.highlightReconcilers">
	221	<highlightReconciler
	222	class="org.eclipse.ui.genericeditor.tests.contributions.HighlightReconciler"
	223	contentType="org.eclipse.ui.genericeditor.tests.content-type-bar">
	224	</highlightReconciler>
	225	<highlightReconciler
	226	class="org.eclipse.ui.genericeditor.tests.contributions.HighlightReconciler"
	227	contentType="org.eclipse.ui.genericeditor.tests.enabled-when-content-type">
	228	<enabledWhen>
	229	<test
	230	forcePluginActivation="true"
	231	property="org.eclipse.ui.genericeditor.tests.contributions.enabled">
	232	</test>
	233	</enabledWhen>
	234	</highlightReconciler>
	235	</extension>
	236	<extension
	237	point="org.eclipse.core.expressions.propertyTesters">
	238	<propertyTester
	239	class="org.eclipse.ui.genericeditor.tests.contributions.EnabledPropertyTester"
	240	id="org.eclipse.ui.genericeditor.tests.contributions.enabled"
	241	namespace="org.eclipse.ui.genericeditor.tests.contributions"
	242	properties="enabled"
	243	type="org.eclipse.ui.internal.genericeditor.ExtensionBasedTextEditor">
	244	</propertyTester>
	245	</extension>
56	246	</plugin>

+2

-2

org.eclipse.ui.genericeditor.tests/pom.xml less more

13	13	<parent>
14	14	<artifactId>tests-pom</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	<relativePath>../tests-pom/</relativePath>
18	18	</parent>
19	19	<groupId>org.eclipse.ui</groupId>
20	20	<artifactId>org.eclipse.ui.genericeditor.tests</artifactId>
21		<version>1.0.0-SNAPSHOT</version>
	21	<version>1.1.0-SNAPSHOT</version>
22	22	<packaging>eclipse-test-plugin</packaging>
23	23	<properties>
24	24	<testSuite>${project.artifactId}</testSuite>

+52

-7

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/AbstratGenericEditorTest.java less more

16	16
17	17	import org.eclipse.swt.widgets.Display;
18	18
	19	import org.eclipse.core.runtime.NullProgressMonitor;
	20
19	21	import org.eclipse.core.resources.IFile;
20	22	import org.eclipse.core.resources.IProject;
21	23	import org.eclipse.core.resources.ResourcesPlugin;
	24
	25	import org.eclipse.text.tests.Accessor;
	26
	27	import org.eclipse.jface.text.source.SourceViewer;
22	28
23	29	import org.eclipse.ui.PlatformUI;
24	30	import org.eclipse.ui.internal.genericeditor.ExtensionBasedTextEditor;
25	31	import org.eclipse.ui.intro.IIntroPart;
26	32	import org.eclipse.ui.part.FileEditorInput;
	33
	34	import org.eclipse.ui.texteditor.AbstractTextEditor;
27	35
28	36	/**
29	37	* Closes intro, create {@link #project}, create {@link #file} and open {@link #editor}; and clean up.

46	54	project = ResourcesPlugin.getWorkspace().getRoot().getProject(getClass().getName() + System.currentTimeMillis());
47	55	project.create(null);
48	56	project.open(null);
49		file = project.getFile("foo.txt");
50		file.create(new ByteArrayInputStream("bar 'bar'".getBytes()), true, null);
51		editor = (ExtensionBasedTextEditor) PlatformUI.getWorkbench().getActiveWorkbenchWindow()
52		.getActivePage().openEditor(new FileEditorInput(this.file), "org.eclipse.ui.genericeditor.GenericEditor");
	57	project.setDefaultCharset("UTF-8", null);
	58	createAndOpenFile();
53	59	}
54	60
	61	protected void createAndOpenFile() throws Exception {
	62	createAndOpenFile("foo.txt", "bar 'bar'");
	63	}
	64
	65	/**
	66	* Creates a new file in the project, opens it, and associate that file with the test state
	67	* @param name name of the file in the project
	68	* @param contents content of the file
	69	* @throws Exception ex
	70	* @since 1.1
	71	*/
	72	protected void createAndOpenFile(String name, String contents) throws Exception {
	73	this.file = project.getFile(name);
	74	this.file.create(new ByteArrayInputStream(contents.getBytes("UTF-8")), true, null);
	75	this.file.setCharset("UTF-8", null);
	76	this.editor = (ExtensionBasedTextEditor) PlatformUI.getWorkbench().getActiveWorkbenchWindow()
	77	.getActivePage().openEditor(new FileEditorInput(this.file), "org.eclipse.ui.genericeditor.GenericEditor");
	78	}
	79
	80	/**
	81	* Closes editor and delete file. Keeps project open.
	82	* @throws Exception ex
	83	* @since 1.1
	84	*/
	85	protected void cleanFileAndEditor() throws Exception {
	86	if (editor != null) {
	87	editor.close(false);
	88	editor = null;
	89	}
	90	while(Display.getDefault().readAndDispatch()) {}
	91	if (file != null) {
	92	file.delete(true, new NullProgressMonitor());
	93	file = null;
	94	}
	95	}
	96
	97	protected SourceViewer getSourceViewer() {
	98	SourceViewer sourceViewer= (SourceViewer) new Accessor(editor, AbstractTextEditor.class).invoke("getSourceViewer", new Object[0]);
	99	return sourceViewer;
	100	}
	101
55	102	@After
56	103	public void tearDown() throws Exception {
57		if (file != null) {
58		file.delete(true, null);
59		}
	104	cleanFileAndEditor();
60	105	if (project != null) {
61	106	project.delete(true, null);
62	107	}

+53

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/AutoEditTest.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Rogue Wave Software Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Michał Niewrzał (Rogue Wave Software Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests;
	11
	12	import org.junit.Assert;
	13	import org.junit.Test;
	14
	15	import org.eclipse.swt.custom.StyledText;
	16	import org.eclipse.swt.widgets.Control;
	17
	18	import org.eclipse.jface.text.IDocument;
	19
	20	import org.eclipse.ui.genericeditor.tests.contributions.EnabledPropertyTester;
	21
	22	public class AutoEditTest extends AbstratGenericEditorTest {
	23
	24	@Test
	25	public void testAutoEdit() throws Exception {
	26	IDocument document= editor.getDocumentProvider().getDocument(editor.getEditorInput());
	27	StyledText control= (StyledText) editor.getAdapter(Control.class);
	28	control.setText("");
	29	// order of auto-edits from most specialized to least specialized
	30	Assert.assertEquals("AutoAddedThird!AutoAddedSecond!AutoAddedFirst!", document.get());
	31	}
	32
	33	@Test
	34	public void testEnabledWhenAutoEdit() throws Exception {
	35	EnabledPropertyTester.setEnabled(true);
	36	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	37	IDocument document= editor.getDocumentProvider().getDocument(editor.getEditorInput());
	38	StyledText control= (StyledText) editor.getAdapter(Control.class);
	39	control.setText("");
	40	// order of auto-edits from most specialized to least specialized
	41	Assert.assertEquals("AutoAddedFirst!", document.get());
	42	cleanFileAndEditor();
	43
	44	EnabledPropertyTester.setEnabled(false);
	45	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	46	document= editor.getDocumentProvider().getDocument(editor.getEditorInput());
	47	control= (StyledText) editor.getAdapter(Control.class);
	48	control.setText("");
	49	// order of auto-edits from most specialized to least specialized
	50	Assert.assertEquals("", document.get());
	51	}
	52	}

+129

-25

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/CompletionTest.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others
	1	* Copyright (c) 2016-2017 Red Hat Inc. and others
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

10	10	package org.eclipse.ui.genericeditor.tests;
11	11
12	12	import static org.junit.Assert.assertEquals;
	13	import static org.junit.Assert.assertNotNull;
13	14	import static org.junit.Assert.assertTrue;
14	15
15	16	import java.util.Arrays;
16		import java.util.HashSet;
17	17	import java.util.Set;
18
	18	import java.util.stream.Collectors;
	19
	20	import org.junit.After;
19	21	import org.junit.Test;
20	22
	23	import org.eclipse.swt.SWT;
	24	import org.eclipse.swt.custom.ST;
	25	import org.eclipse.swt.custom.StyledText;
21	26	import org.eclipse.swt.widgets.Composite;
22		import org.eclipse.swt.widgets.Display;
	27	import org.eclipse.swt.widgets.Control;
	28	import org.eclipse.swt.widgets.Event;
23	29	import org.eclipse.swt.widgets.Shell;
24	30	import org.eclipse.swt.widgets.Table;
25	31	import org.eclipse.swt.widgets.TableItem;
26	32	import org.eclipse.swt.widgets.Widget;
27	33
	34	import org.eclipse.jface.text.ITextSelection;
28	35	import org.eclipse.jface.text.contentassist.ICompletionProposal;
29	36	import org.eclipse.jface.text.tests.util.DisplayHelper;
30	37
31	38	import org.eclipse.ui.genericeditor.tests.contributions.BarContentAssistProcessor;
	39	import org.eclipse.ui.genericeditor.tests.contributions.EnabledPropertyTester;
32	40	import org.eclipse.ui.genericeditor.tests.contributions.LongRunningBarContentAssistProcessor;
33	41
34	42	import org.eclipse.ui.texteditor.ContentAssistAction;

39	47	*/
40	48	public class CompletionTest extends AbstratGenericEditorTest {
41	49
	50	private Shell completionShell;
	51
42	52	@Test
43	53	public void testCompletion() throws Exception {
44		Set<Shell> beforeShell = new HashSet<>(Arrays.asList(Display.getDefault().getShells()));
	54	final Set<Shell> beforeShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells()).filter(Shell::isVisible).collect(Collectors.toSet());
	55	openConentAssist();
	56	this.completionShell= findNewShell(beforeShells);
	57	final Table completionProposalList = findCompletionSelectionControl(completionShell);
	58	checkCompletionContent(completionProposalList);
	59	// TODO find a way to actually trigger completion and verify result against Editor content
	60	// Assert.assertEquals("Completion didn't complete", "bars are good for a beer.", ((StyledText)editor.getAdapter(Control.class)).getText());
	61	}
	62
	63	@Test
	64	public void testEnabledWhenCompletion() throws Exception {
	65	// Confirm that when disabled, a completion shell is present
	66	EnabledPropertyTester.setEnabled(false);
	67	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	68	final Set<Shell> beforeShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells()).filter(Shell::isVisible).collect(Collectors.toSet());
	69	openConentAssist();
	70	Shell[] afterShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells())
	71	.filter(Shell::isVisible)
	72	.filter(shell -> !beforeShells.contains(shell))
	73	.toArray(Shell[]::new);
	74	assertEquals("A new shell was found", 0, afterShells.length);
	75	cleanFileAndEditor();
	76
	77	// Confirm that when enabled, a completion shell is present
	78	EnabledPropertyTester.setEnabled(true);
	79	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	80	final Set<Shell> beforeEnabledShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells()).filter(Shell::isVisible).collect(Collectors.toSet());
	81	openConentAssist();
	82	assertNotNull(findNewShell(beforeEnabledShells));
	83	}
	84
	85	private void openConentAssist() {
45	86	editor.selectAndReveal(3, 0);
46	87	ContentAssistAction action = (ContentAssistAction) editor.getAction(ITextEditorActionConstants.CONTENT_ASSIST);
47	88	action.update();
48	89	action.run();
49	90	waitAndDispatch(100);
50		Set<Shell> afterShell = new HashSet<>(Arrays.asList(Display.getDefault().getShells()));
51		afterShell.removeAll(beforeShell);
52		assertEquals("No completion", 1, afterShell.size());
53		Shell completionShell= afterShell.iterator().next();
54		final Table completionProposalList = findCompletionSelectionControl(completionShell);
	91	}
	92
	93	/**
	94	* Checks that completion behaves as expected:
	95	* 1. Computing is shown instantaneously
	96	* 2. 1st proposal shown instantaneously
	97	* 3. 2s later, 2nd proposal is shown
	98	* @param completionProposalList the completion list
	99	*/
	100	private void checkCompletionContent(final Table completionProposalList) {
55	101	// should be instantaneous, but happens to go asynchronous on CI so let's allow a wait
56	102	new DisplayHelper() {
57	103	@Override
58	104	protected boolean condition() {
59	105	return completionProposalList.getItemCount() == 2;
60	106	}
61		}.waitForCondition(completionShell.getDisplay(), 200);
	107	}.waitForCondition(completionProposalList.getDisplay(), 200);
62	108	assertEquals(2, completionProposalList.getItemCount());
63	109	final TableItem computingItem = completionProposalList.getItem(0);
64	110	assertTrue("Missing computing info entry", computingItem.getText().contains("Computing")); //$NON-NLS-1$ //$NON-NLS-2$
65	111	TableItem completionProposalItem = completionProposalList.getItem(1);
66		ICompletionProposal completionProposal = (ICompletionProposal)completionProposalItem.getData();
67		assertEquals(BarContentAssistProcessor.PROPOSAL, completionProposal .getDisplayString());
	112	final ICompletionProposal selectedProposal = (ICompletionProposal)completionProposalItem.getData();
	113	assertTrue("Incorrect proposal content", BarContentAssistProcessor.PROPOSAL.endsWith(selectedProposal .getDisplayString()));
68	114	completionProposalList.setSelection(completionProposalItem);
69	115	// asynchronous
70	116	new DisplayHelper() {
71	117	@Override
72	118	protected boolean condition() {
73		return completionProposalList.getItem(0) != computingItem;
74		}
75		}.waitForCondition(completionShell.getDisplay(), LongRunningBarContentAssistProcessor.DELAY + 200);
	119	return completionProposalList.getItem(0) != computingItem && completionProposalList.getItemCount() == 2;
	120	}
	121	}.waitForCondition(completionProposalList.getDisplay(), LongRunningBarContentAssistProcessor.DELAY + 200);
	122	completionProposalItem = completionProposalList.getItem(0);
	123	assertTrue("Proposal content seems incorrect", BarContentAssistProcessor.PROPOSAL.endsWith(((ICompletionProposal)completionProposalItem.getData()).getDisplayString()));
	124	TableItem otherProposalItem = completionProposalList.getItem(1);
	125	assertTrue("Proposal content seems incorrect", LongRunningBarContentAssistProcessor.PROPOSAL.endsWith(((ICompletionProposal)otherProposalItem.getData()).getDisplayString()));
	126	assertEquals("Addition of completion proposal should keep selection", selectedProposal, completionProposalList.getSelection()[0].getData());
	127	}
	128
	129	private Shell findNewShell(Set<Shell> beforeShells) {
	130	Shell[] afterShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells())
	131	.filter(Shell::isVisible)
	132	.filter(shell -> !beforeShells.contains(shell))
	133	.toArray(Shell[]::new);
	134	assertEquals("No new shell found", 1, afterShells.length);
	135	return afterShells[0];
	136	}
	137
	138	@Test
	139	public void testCompletionFreeze_bug521484() throws Exception {
	140	final Set<Shell> beforeShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells()).filter(Shell::isVisible).collect(Collectors.toSet());
	141	openConentAssist();
	142	this.completionShell= findNewShell(beforeShells);
	143	final Table completionProposalList = findCompletionSelectionControl(this.completionShell);
	144	// should be instantaneous, but happens to go asynchronous on CI so let's allow a wait
	145	new DisplayHelper() {
	146	@Override
	147	protected boolean condition() {
	148	return completionProposalList.getItemCount() == 2;
	149	}
	150	}.waitForCondition(completionShell.getDisplay(), 200);
76	151	assertEquals(2, completionProposalList.getItemCount());
77		completionProposalItem = completionProposalList.getItem(0);
78		assertEquals(BarContentAssistProcessor.PROPOSAL, ((ICompletionProposal)completionProposalItem.getData()).getDisplayString());
79		TableItem otherProposalItem = completionProposalList.getItem(1);
80		assertEquals(LongRunningBarContentAssistProcessor.PROPOSAL, ((ICompletionProposal)otherProposalItem.getData()).getDisplayString());
81		assertEquals("Addition of completion proposal should keep selection", completionProposal, completionProposalList.getSelection()[0].getData());
82
83		// TODO find a way to actually trigger completion and verify result against Editor content
84		// Assert.assertEquals("Completion didn't complete", "bars are good for a beer.", ((StyledText)editor.getAdapter(Control.class)).getText());
85		completionShell.close();
	152	final TableItem computingItem = completionProposalList.getItem(0);
	153	assertTrue("Missing computing info entry", computingItem.getText().contains("Computing")); //$NON-NLS-1$ //$NON-NLS-2$
	154	// Some processors are long running, moving cursor can cause freeze (bug 521484)
	155	// asynchronous
	156	long timestamp = System.currentTimeMillis();
	157	emulatePressLeftArrowKey();
	158	DisplayHelper.sleep(editor.getSite().getShell().getDisplay(), 200); //give time to process events
	159	long processingDuration = System.currentTimeMillis() - timestamp;
	160	assertTrue("UI Thread frozen for " + processingDuration + "ms", processingDuration < LongRunningBarContentAssistProcessor.DELAY);
	161	}
	162
	163	@Test
	164	public void testMoveCaretBackUsesAllProcessors_bug522255() throws Exception {
	165	final Set<Shell> beforeShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells()).filter(Shell::isVisible).collect(Collectors.toSet());
	166	testCompletion();
	167	emulatePressLeftArrowKey();
	168	DisplayHelper.sleep(editor.getSite().getShell().getDisplay(), LongRunningBarContentAssistProcessor.DELAY + 500); // adding delay is a workaround for bug521484, use only 100ms without the bug
	169	this.completionShell= findNewShell(beforeShells);
	170	final Table completionProposalList = findCompletionSelectionControl(this.completionShell);
	171	assertEquals("Missing proposals from a Processor", 2, completionProposalList.getItemCount()); // replace with line below when #5214894 is done
	172	// checkCompletionContent(completionProposalList); // use this instead of assert above when #521484 is done
	173	}
	174
	175	private void emulatePressLeftArrowKey() {
	176	editor.selectAndReveal(((ITextSelection)editor.getSelectionProvider().getSelection()).getOffset() - 1, 0);
	177	StyledText styledText = (StyledText) editor.getAdapter(Control.class);
	178	Event e = new Event();
	179	e.type = ST.VerifyKey;
	180	e.widget = styledText;
	181	e.keyCode = SWT.ARROW_LEFT;
	182	e.display = styledText.getDisplay();
	183	styledText.notifyListeners(ST.VerifyKey, e);
86	184	}
87	185
88	186	private Table findCompletionSelectionControl(Widget control) {

99	197	return null;
100	198	}
101	199
	200	@After
	201	public void closeShell() {
	202	if (this.completionShell != null && !completionShell.isDisposed()) {
	203	completionShell.close();
	204	}
	205	}
102	206	}

+126

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/ContextInfoTest.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Stephan Wahlbrink and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Stephan Wahlbrink <sw@wahlbrink.eu>
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests;
	11
	12	import static org.junit.Assert.assertEquals;
	13	import static org.junit.Assert.assertTrue;
	14
	15	import java.util.Arrays;
	16	import java.util.Set;
	17	import java.util.stream.Collectors;
	18
	19	import org.junit.After;
	20	import org.junit.Test;
	21
	22	import org.eclipse.swt.custom.StyledText;
	23	import org.eclipse.swt.widgets.Control;
	24	import org.eclipse.swt.widgets.Shell;
	25	import org.eclipse.swt.widgets.Text;
	26
	27	import org.eclipse.text.tests.Accessor;
	28
	29	import org.eclipse.jface.text.contentassist.ContentAssistant;
	30	import org.eclipse.jface.text.source.SourceViewer;
	31
	32	import org.eclipse.ui.genericeditor.tests.contributions.BarContentAssistProcessor;
	33
	34	import org.eclipse.ui.texteditor.ITextEditorActionConstants;
	35	import org.eclipse.ui.texteditor.TextOperationAction;
	36
	37
	38	public class ContextInfoTest extends AbstratGenericEditorTest {
	39
	40
	41	private Shell completionShell;
	42
	43
	44	@Test
	45	public void testContextInfo() throws Exception {
	46	cleanFileAndEditor();
	47	createAndOpenFile("foobar.txt", BarContentAssistProcessor.PROPOSAL);
	48
	49	final Set<Shell> beforeShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells()).filter(Shell::isVisible).collect(Collectors.toSet());
	50	TextOperationAction action = (TextOperationAction) editor.getAction(ITextEditorActionConstants.CONTENT_ASSIST_CONTEXT_INFORMATION);
	51
	52	editor.selectAndReveal(4, 0);
	53	action.update();
	54	action.run();
	55	waitAndDispatch(100);
	56	this.completionShell= findNewShell(beforeShells);
	57	assertEquals("idx= 0", getInfoText(this.completionShell));
	58
	59	editor.selectAndReveal(8, 0);
	60	action.update();
	61	action.run();
	62	waitAndDispatch(100);
	63	this.completionShell= findNewShell(beforeShells);
	64	assertEquals("idx= 1", getInfoText(this.completionShell));
	65	}
	66
	67	@Test
	68	public void testContextInfo_hide_Bug512251() throws Exception {
	69	cleanFileAndEditor();
	70	createAndOpenFile("foobar.txt", BarContentAssistProcessor.PROPOSAL);
	71
	72	final Set<Shell> beforeShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells()).filter(Shell::isVisible).collect(Collectors.toSet());
	73	TextOperationAction action = (TextOperationAction) editor.getAction(ITextEditorActionConstants.CONTENT_ASSIST_CONTEXT_INFORMATION);
	74
	75	editor.selectAndReveal(4, 0);
	76	action.update();
	77	action.run();
	78	waitAndDispatch(100);
	79	this.completionShell= findNewShell(beforeShells);
	80
	81	editor.selectAndReveal(8, 0);
	82	action.update();
	83	action.run();
	84	waitAndDispatch(100);
	85	this.completionShell= findNewShell(beforeShells);
	86
	87	editor.getAction(ITextEditorActionConstants.DELETE_LINE).run();
	88
	89	SourceViewer sourceViewer= getSourceViewer();
	90	ContentAssistant assist= (ContentAssistant) new Accessor(sourceViewer, SourceViewer.class).get("fContentAssistant");
	91	new Accessor(assist, ContentAssistant.class).invoke("hide", new Object[0]);
	92	}
	93
	94
	95	private Shell findNewShell(Set<Shell> beforeShells) {
	96	Shell[] afterShells = Arrays.stream(editor.getSite().getShell().getDisplay().getShells())
	97	.filter(Shell::isVisible)
	98	.filter(shell -> !beforeShells.contains(shell))
	99	.toArray(Shell[]::new);
	100	assertEquals("No new shell found", 1, afterShells.length);
	101	return afterShells[0];
	102	}
	103
	104	private String getInfoText(final Shell shell) {
	105	assertTrue(shell.isVisible());
	106	Control[] children= shell.getChildren();
	107	for (Control child : children) {
	108	if (child instanceof Text) {
	109	return ((Text) child).getText();
	110	}
	111	if (child instanceof StyledText) {
	112	return ((StyledText) child).getText();
	113	}
	114	}
	115	return null;
	116	}
	117
	118	@After
	119	public void closeShell() {
	120	if (this.completionShell != null && !completionShell.isDisposed()) {
	121	completionShell.close();
	122	}
	123	}
	124
	125	}

+7

-2

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/GenericEditorTestSuite.java less more

6	6	*
7	7	* Contributors:
8	8	* Mickael Istria, Sopot Cela (Red Hat Inc.)
	9	* Lucas Bullen (Red Hat Inc.)
9	10	*******************************************************************************/
10	11	package org.eclipse.ui.genericeditor.tests;
11	12

16	17	@RunWith(Suite.class)
17	18	@SuiteClasses({
18	19	CompletionTest.class,
	20	ContextInfoTest.class,
19	21	StylingTest.class,
20	22	HoverTest.class,
21		EditorTest.class
	23	EditorTest.class,
	24	AutoEditTest.class,
	25	ReconcilerTest.class,
	26	HighlightTest.class
22	27	})
23	28	public class GenericEditorTestSuite {
24	29	// see @SuiteClasses
25
	30
26	31	}

+161

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/HighlightTest.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017, 2018 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Lucas Bullen (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests;
	11
	12	import static org.junit.Assert.assertEquals;
	13
	14	import java.util.ArrayList;
	15	import java.util.Iterator;
	16	import java.util.List;
	17
	18	import org.junit.Assert;
	19	import org.junit.Test;
	20
	21	import org.eclipse.swt.widgets.Display;
	22
	23	import org.eclipse.jface.text.IDocument;
	24	import org.eclipse.jface.text.Position;
	25	import org.eclipse.jface.text.source.Annotation;
	26	import org.eclipse.jface.text.source.IAnnotationModel;
	27	import org.eclipse.jface.text.tests.util.DisplayHelper;
	28
	29	import org.eclipse.ui.genericeditor.tests.contributions.EnabledPropertyTester;
	30
	31	import org.eclipse.ui.texteditor.IDocumentProvider;
	32
	33	public class HighlightTest extends AbstratGenericEditorTest {
	34
	35	private static final String ANNOTATION_TYPE= "org.eclipse.ui.genericeditor.text"; //$NON-NLS-1$
	36
	37	private static final String EDITOR_TEXT= "Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n" +
	38	"Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n" +
	39	"Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
	40
	41	@Override
	42	protected void createAndOpenFile() throws Exception {
	43	//leave editor creation to individual tests
	44	}
	45
	46	@Test
	47	public void testCustomHighlightReconciler() throws Exception {
	48	createAndOpenFile("bar.txt", "bar 'bar'");
	49
	50	checkHighlightForCaretOffset(0, "'bar'", 1);
	51	}
	52
	53	@Test
	54	public void testEnabledWhenCustomHighlightReconciler() throws Exception {
	55	EnabledPropertyTester.setEnabled(true);
	56	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	57	checkHighlightForCaretOffset(0, "'bar'", 1);
	58	cleanFileAndEditor();
	59
	60	EnabledPropertyTester.setEnabled(false);
	61	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	62	checkHighlightForCaretOffset(0, "'bar'", 0);
	63	}
	64
	65	@Test
	66	public void testHighlightWordAtDocumentStart() throws Exception {
	67	createAndOpenFile("foo.txt", EDITOR_TEXT);
	68
	69	checkHighlightForCaretOffset(0, "Lorem", 3);
	70	}
	71
	72	@Test
	73	public void testHighlightWordWithNonLetterParts() throws Exception {
	74	String complexWord= "dolor_sit123amet45";
	75	String editorText= EDITOR_TEXT.replaceFirst("dolor sit amet", complexWord).replaceFirst("dolor sit amet", complexWord);
	76	createAndOpenFile("foo.txt", editorText);
	77
	78	checkHighlightForCaretOffset(editorText.indexOf("dolor") + 3, complexWord, 2);
	79	checkHighlightForCaretOffset(editorText.indexOf("_sit") + 3, complexWord, 2);
	80	checkHighlightForCaretOffset(editorText.indexOf("123") + 1, complexWord, 2);
	81	checkHighlightForCaretOffset(editorText.indexOf("amet") + 1, complexWord, 2);
	82	}
	83
	84	@Test
	85	public void testHighlightSimpleWordNotMatchingWordPart() throws Exception {
	86	String complexWord= "dolor_sit123amet45";
	87	String editorText= EDITOR_TEXT.replaceFirst("dolor sit amet", complexWord);
	88	createAndOpenFile("foo.txt", editorText);
	89
	90	checkHighlightForCaretOffset(editorText.indexOf("dolor ") + 1, "dolor", 2);
	91	checkHighlightForCaretOffset(editorText.indexOf(" sit") + 1, "sit", 2);
	92	checkHighlightForCaretOffset(editorText.indexOf(" amet") + 1, "amet", 2);
	93	}
	94
	95	@Test
	96	public void testHighlightNonAsciiCharacters() throws Exception {
	97	String complexWord= "sit\u00f6\u00f6amet";
	98	String editorText= EDITOR_TEXT.replaceFirst("sit amet", complexWord).replaceFirst("sit amet", complexWord);
	99	createAndOpenFile("foo.txt", editorText);
	100
	101	checkHighlightForCaretOffset(editorText.indexOf("sit") + 1, complexWord, 2);
	102	checkHighlightForCaretOffset(editorText.indexOf("\u00f6") + 1, complexWord, 2);
	103	checkHighlightForCaretOffset(editorText.indexOf("amet") + 1, complexWord, 2);
	104	}
	105
	106	private void checkHighlightForCaretOffset(int pos, String expectedHighlight, int expectedHighlightCount) throws Exception {
	107	clearAnnotations();
	108
	109	editor.selectAndReveal(pos, 0);
	110	waitForAnnotations(expectedHighlightCount);
	111
	112	List<Annotation> annotations= getAnnotationsFromAnnotationModel();
	113
	114	IAnnotationModel annotationModel= getAnnotationModel();
	115	IDocument document= editor.getDocumentProvider().getDocument(editor.getEditorInput());
	116	for (int i= 0; i < annotations.size(); i++) {
	117	Annotation annotation= annotations.get(i);
	118	Position position= annotationModel.getPosition(annotation);
	119	String highlight= document.get(position.offset, position.length);
	120	assertEquals("Wrong highlight " + i + " at position " + position.offset, expectedHighlight, highlight);
	121	}
	122	Assert.assertEquals("Wrong number of highlights", expectedHighlightCount, annotations.size());
	123	}
	124
	125	private void clearAnnotations() {
	126	editor.selectAndReveal(0, 0);
	127	IAnnotationModel annotationModel= getAnnotationModel();
	128	List<Annotation> annotations= getAnnotationsFromAnnotationModel();
	129	for (Annotation annotation : annotations) {
	130	annotationModel.removeAnnotation(annotation);
	131	}
	132	}
	133
	134	private IAnnotationModel getAnnotationModel() {
	135	IDocumentProvider dp= editor.getDocumentProvider();
	136	IAnnotationModel am= dp.getAnnotationModel(editor.getEditorInput());
	137	return am;
	138	}
	139
	140	private void waitForAnnotations(int count) {
	141	new DisplayHelper() {
	142	@Override
	143	protected boolean condition() {
	144	return getAnnotationsFromAnnotationModel().size() == count;
	145	}
	146	}.waitForCondition(Display.getDefault(), 2000);
	147	}
	148
	149	private List<Annotation> getAnnotationsFromAnnotationModel() {
	150	List<Annotation> annotationList= new ArrayList<>();
	151	Iterator<Annotation> annotationIterator= getAnnotationModel().getAnnotationIterator();
	152	while (annotationIterator.hasNext()) {
	153	Annotation ann= annotationIterator.next();
	154	if (ann.getType().indexOf(ANNOTATION_TYPE) > -1) {
	155	annotationList.add(ann);
	156	}
	157	}
	158	return annotationList;
	159	}
	160	}

+56

-6

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/HoverTest.java less more

9	9	*******************************************************************************/
10	10	package org.eclipse.ui.genericeditor.tests;
11	11
12		import static org.junit.Assert.assertEquals;
13	12	import static org.junit.Assert.assertFalse;
14	13	import static org.junit.Assert.assertNotNull;
	14	import static org.junit.Assert.assertNull;
15	15	import static org.junit.Assert.assertTrue;
16	16	import static org.junit.Assert.fail;
17	17
18	18	import java.util.Collections;
	19	import java.util.Map;
19	20
20	21	import org.junit.Assume;
21	22	import org.junit.Before;

45	46	import org.eclipse.jface.text.TextViewer;
46	47	import org.eclipse.jface.text.tests.util.DisplayHelper;
47	48
48		import org.eclipse.ui.genericeditor.tests.contributions.MagicHoverProvider;
	49	import org.eclipse.ui.genericeditor.tests.contributions.AlrightyHoverProvider;
	50	import org.eclipse.ui.genericeditor.tests.contributions.EnabledPropertyTester;
	51	import org.eclipse.ui.genericeditor.tests.contributions.HelloHoverProvider;
49	52	import org.eclipse.ui.genericeditor.tests.contributions.MarkerResolutionGenerator;
	53	import org.eclipse.ui.genericeditor.tests.contributions.WorldHoverProvider;
50	54
51	55	import org.eclipse.ui.workbench.texteditor.tests.ScreenshotTest;
52	56

66	70	}
67	71
68	72	@Test
69		public void testHover() throws Exception {
	73	public void testSingleHover() throws Exception {
70	74	Shell shell = getHoverShell(triggerCompletionAndRetrieveInformationControlManager());
71		assertNotNull(findControl(shell, StyledText.class, MagicHoverProvider.LABEL));
	75	assertNotNull(findControl(shell, StyledText.class, AlrightyHoverProvider.LABEL));
	76	assertNull(findControl(shell, StyledText.class, HelloHoverProvider.LABEL));
	77	assertNull(findControl(shell, StyledText.class, WorldHoverProvider.LABEL));
	78	}
	79
	80	@Test
	81	public void testEnabledWhenHover() throws Exception {
	82	EnabledPropertyTester.setEnabled(true);
	83	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	84	Shell shell = getHoverShell(triggerCompletionAndRetrieveInformationControlManager());
	85	assertNotNull(findControl(shell, StyledText.class, AlrightyHoverProvider.LABEL));
	86	assertNull(findControl(shell, StyledText.class, WorldHoverProvider.LABEL));
	87	cleanFileAndEditor();
	88
	89	EnabledPropertyTester.setEnabled(false);
	90	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	91	shell = getHoverShell(triggerCompletionAndRetrieveInformationControlManager());
	92	assertNull(findControl(shell, StyledText.class, AlrightyHoverProvider.LABEL));
	93	assertNotNull(findControl(shell, StyledText.class, WorldHoverProvider.LABEL));
	94	}
	95
	96	/**
	97	* @throws Exception ex
	98	* @since 1.1
	99	*/
	100	@Test
	101	public void testMultipleHover() throws Exception {
	102	cleanFileAndEditor();
	103	createAndOpenFile("bar.txt", "Hi");
	104	Shell shell = getHoverShell(triggerCompletionAndRetrieveInformationControlManager());
	105	assertNull(findControl(shell, StyledText.class, AlrightyHoverProvider.LABEL));
	106	assertNotNull(findControl(shell, StyledText.class, WorldHoverProvider.LABEL));
	107	assertNotNull(findControl(shell, StyledText.class, HelloHoverProvider.LABEL));
72	108	}
73	109
74	110	@Test

84	120	marker.setAttribute(IMarker.MESSAGE, problemMessage);
85	121	marker.setAttribute(MarkerResolutionGenerator.FIXME, true);
86	122	AbstractInformationControlManager manager = triggerCompletionAndRetrieveInformationControlManager();
87		assertEquals(Collections.singletonList(marker), getHoverData(manager));
	123	Object hoverData = getHoverData(manager);
	124	assertTrue(hoverData instanceof Map);
	125	assertTrue(((Map<?,?>)hoverData).containsValue(Collections.singletonList(marker)));
	126	assertTrue(((Map<?,?>)hoverData).containsValue(AlrightyHoverProvider.LABEL));
	127	assertFalse(((Map<?,?>)hoverData).containsValue(HelloHoverProvider.LABEL));
88	128	// check dialog content
89	129	Shell shell= getHoverShell(manager);
90	130	assertNotNull(findControl(shell, Label.class, marker.getAttribute(IMarker.MESSAGE, "NONE")));
	131	assertNotNull(findControl(shell, StyledText.class, AlrightyHoverProvider.LABEL));
	132	assertNull(findControl(shell, StyledText.class, HelloHoverProvider.LABEL));
	133	// check quick-fix works
91	134	Link link = findControl(shell, Link.class, MarkerResolutionGenerator.FIXME);
92	135	assertNotNull(link);
93	136	Event event = new Event();

125	168	fail();
126	169	}
127	170	Shell shell = (Shell)new Accessor(control[0], AbstractInformationControl.class).get("fShell");
	171	new DisplayHelper() {
	172	@Override
	173	protected boolean condition() {
	174	return shell.isVisible();
	175	}
	176	}.waitForCondition(this.editor.getSite().getShell().getDisplay(), 2000);
128	177	assertTrue(shell.isVisible());
129	178	return shell;
130	179	}
131	180
132	181	private <T extends Control> T findControl(Control control, Class<T> controlType, String label) {
133	182	if (control.getClass() == controlType) {
134		T res = (T)control;
	183	@SuppressWarnings("unchecked")
	184	T res = (T) control;
135	185	if (label == null) {
136	186	return res;
137	187	}

+121

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/ReconcilerTest.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests;
	11
	12	import java.io.ByteArrayInputStream;
	13
	14	import org.junit.Assert;
	15	import org.junit.Test;
	16
	17	import org.eclipse.swt.widgets.Display;
	18
	19	import org.eclipse.core.runtime.NullProgressMonitor;
	20
	21	import org.eclipse.core.resources.IFile;
	22	import org.eclipse.core.resources.IProject;
	23	import org.eclipse.core.resources.ResourcesPlugin;
	24
	25	import org.eclipse.jface.text.BadLocationException;
	26	import org.eclipse.jface.text.IDocument;
	27	import org.eclipse.jface.text.tests.util.DisplayHelper;
	28
	29	import org.eclipse.ui.PlatformUI;
	30	import org.eclipse.ui.genericeditor.tests.contributions.EnabledPropertyTester;
	31	import org.eclipse.ui.genericeditor.tests.contributions.ReconcilerStrategyFirst;
	32	import org.eclipse.ui.genericeditor.tests.contributions.ReconcilerStrategySecond;
	33	import org.eclipse.ui.internal.genericeditor.ExtensionBasedTextEditor;
	34	import org.eclipse.ui.part.FileEditorInput;
	35
	36	import org.eclipse.ui.texteditor.IDocumentProvider;
	37
	38	public class ReconcilerTest extends AbstratGenericEditorTest {
	39
	40	protected ExtensionBasedTextEditor secondEditor;
	41	protected IFile secondFile;
	42	protected IProject secondProject;
	43
	44	@Test
	45	public void testReconciler() throws Exception {
	46	performTestOnEditor(ReconcilerStrategyFirst.SEARCH_TERM, editor, ReconcilerStrategyFirst.REPLACEMENT);
	47	}
	48
	49	@Test
	50	public void testEnabledWhenReconciler() throws Exception {
	51	EnabledPropertyTester.setEnabled(true);
	52	createAndOpenFile("enabledWhen.txt", "");
	53	performTestOnEditor(ReconcilerStrategyFirst.SEARCH_TERM, editor, ReconcilerStrategyFirst.REPLACEMENT);
	54	cleanFileAndEditor();
	55
	56	EnabledPropertyTester.setEnabled(false);
	57	createAndOpenFile("enabledWhen.txt", "");
	58	performTestOnEditor(ReconcilerStrategySecond.SEARCH_TERM, editor, ReconcilerStrategySecond.REPLACEMENT);
	59	}
	60
	61	@Test
	62	public void testMultipleEditors() throws Exception {
	63	secondProject= ResourcesPlugin.getWorkspace().getRoot().getProject(getClass().getName() + System.currentTimeMillis());
	64	secondProject.create(null);
	65	secondProject.open(null);
	66	secondFile= secondProject.getFile("foo.txt");
	67	secondFile.create(new ByteArrayInputStream("bar 'bar'".getBytes()), true, null);
	68	secondEditor = (ExtensionBasedTextEditor) PlatformUI.getWorkbench().getActiveWorkbenchWindow()
	69	.getActivePage().openEditor(new FileEditorInput(secondFile), "org.eclipse.ui.genericeditor.GenericEditor");
	70	performTestOnEditor(ReconcilerStrategyFirst.SEARCH_TERM, editor, ReconcilerStrategyFirst.REPLACEMENT);
	71	}
	72
	73	@Test
	74	public void testMultipleReconcilers() throws Exception {
	75	secondFile = project.getFile("bar.txt");
	76	secondFile.create(new ByteArrayInputStream("".getBytes()), true, null);
	77	secondEditor = (ExtensionBasedTextEditor) PlatformUI.getWorkbench().getActiveWorkbenchWindow()
	78	.getActivePage().openEditor(new FileEditorInput(secondFile), "org.eclipse.ui.genericeditor.GenericEditor");
	79	performTestOnEditor(ReconcilerStrategyFirst.SEARCH_TERM, secondEditor, ReconcilerStrategySecond.REPLACEMENT);
	80	}
	81
	82	private void performTestOnEditor(String startingText, ExtensionBasedTextEditor textEditor, String expectedText) throws Exception {
	83	IDocumentProvider dp = textEditor.getDocumentProvider();
	84	IDocument doc = dp.getDocument(textEditor.getEditorInput());
	85
	86	doc.set(startingText);
	87
	88	new DisplayHelper() {
	89	@Override
	90	protected boolean condition() {
	91	try {
	92	return doc.get(0, doc.getLineLength(0)).contains(expectedText);
	93	} catch (BadLocationException e) {
	94	return false;
	95	}
	96	}
	97	}.waitForCondition(Display.getDefault().getActiveShell().getDisplay(), 2000);
	98	Assert.assertTrue("file was not affected by reconciler", doc.get().contains(expectedText));
	99	}
	100
	101	@Override
	102	public void tearDown() throws Exception {
	103	if (secondEditor != null)
	104	{
	105	secondEditor.close(false);
	106	secondEditor = null;
	107	while(Display.getDefault().readAndDispatch()) {}
	108	}
	109	if (secondFile != null)
	110	{
	111	secondFile.delete(true, new NullProgressMonitor());
	112	secondFile = null;
	113	}
	114	super.tearDown();
	115	if (secondProject != null)
	116	{
	117	secondProject.delete(true, new NullProgressMonitor());
	118	}
	119	}
	120	}

+22

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/StylingTest.java less more

9	9	*******************************************************************************/
10	10	package org.eclipse.ui.genericeditor.tests;
11	11
	12	import static org.junit.Assert.assertNull;
	13
12	14	import org.junit.Assert;
13	15	import org.junit.Test;
14	16

16	18	import org.eclipse.swt.custom.StyledText;
17	19	import org.eclipse.swt.graphics.RGB;
18	20	import org.eclipse.swt.widgets.Control;
	21
	22	import org.eclipse.ui.genericeditor.tests.contributions.EnabledPropertyTester;
19	23
20	24	public class StylingTest extends AbstratGenericEditorTest {
21	25

28	32	Assert.assertTrue("Token is not of expected color", isRed);
29	33	}
30	34
	35	@Test
	36	public void testEnabledWhenStyle() throws Exception {
	37	EnabledPropertyTester.setEnabled(true);
	38	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	39	editor.selectAndReveal(4, 8);
	40	StyledText widget = (StyledText) editor.getAdapter(Control.class);
	41	StyleRange style= widget.getStyleRangeAtOffset(4);//get the style of first token
	42	boolean isBlue= style.foreground.getRGB().equals(new RGB(0, 0, 255));//is it Blue?
	43	Assert.assertTrue("Token is not of expected color", isBlue);
	44	cleanFileAndEditor();
	45
	46	EnabledPropertyTester.setEnabled(false);
	47	createAndOpenFile("enabledWhen.txt", "bar 'bar'");
	48	editor.selectAndReveal(4, 8);
	49	widget = (StyledText) editor.getAdapter(Control.class);
	50	assertNull(widget.getStyleRangeAtOffset(4));
	51	}
	52
31	53	}

+39

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/AlrightyHoverProvider.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2016 Red Hat Inc. and others
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Mickael Istria (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.jface.text.IRegion;
	13	import org.eclipse.jface.text.ITextHover;
	14	import org.eclipse.jface.text.ITextHoverExtension2;
	15	import org.eclipse.jface.text.ITextViewer;
	16	import org.eclipse.jface.text.Region;
	17
	18	public class AlrightyHoverProvider implements ITextHover,ITextHoverExtension2 {
	19
	20	public static final String LABEL= "Alrighty!";
	21
	22	@Deprecated
	23	@Override
	24	public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {
	25	return null;
	26	}
	27
	28	@Override
	29	public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
	30	return new Region(0, textViewer.getTextWidget().getText().length());
	31	}
	32
	33	@Override
	34	public Object getHoverInfo2(ITextViewer textViewer, IRegion hoverRegion) {
	35	return LABEL;
	36	}
	37
	38	}

+78

-16

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/BarContentAssistProcessor.java less more

6	6	*
7	7	* Contributors:
8	8	* - Mickael Istria (Red Hat Inc.)
	9	* Stephan Wahlbrink <sw@wahlbrink.eu> - Bug 512251 - Fix IllegalArgumentException in ContextInformationPopup
9	10	*******************************************************************************/
10	11	package org.eclipse.ui.genericeditor.tests.contributions;
11	12
	13	import java.util.Arrays;
	14
	15	import org.eclipse.jface.text.BadLocationException;
	16	import org.eclipse.jface.text.IDocument;
	17	import org.eclipse.jface.text.IRegion;
12	18	import org.eclipse.jface.text.ITextViewer;
13	19	import org.eclipse.jface.text.contentassist.CompletionProposal;
	20	import org.eclipse.jface.text.contentassist.ContextInformation;
14	21	import org.eclipse.jface.text.contentassist.ICompletionProposal;
15	22	import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
16	23	import org.eclipse.jface.text.contentassist.IContextInformation;

18	25
19	26	public class BarContentAssistProcessor implements IContentAssistProcessor {
20	27
21		public static final String PROPOSAL = "s are good for a beer.";
	28	public static final String PROPOSAL = "bars are good for a beer.";
	29	private final String completeString;
	30
	31	public BarContentAssistProcessor() {
	32	this(PROPOSAL);
	33	}
	34
	35	public BarContentAssistProcessor(String completeString) {
	36	this.completeString = completeString;
	37	}
22	38
23	39	@Override
24	40	public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
25		String text = viewer.getDocument().get();
26		if (text.length() >= 3 && text.substring(offset - 3, offset).equals("bar")) {
27		String message = PROPOSAL;
28		CompletionProposal proposal = new CompletionProposal(message, offset, 0, message.length());
29		return new ICompletionProposal[] { proposal };
	41	for (int offsetInProposal = Math.min(this.completeString.length(), viewer.getDocument().getLength()); offsetInProposal > 0; offsetInProposal--) {
	42	String maybeMatchingString = this.completeString.substring(0, offsetInProposal);
	43	try {
	44	int lastIndex = offset - offsetInProposal + this.completeString.length();
	45	if (offset >= offsetInProposal && viewer.getDocument().get(offset - offsetInProposal, maybeMatchingString.length()).equals(maybeMatchingString)) {
	46	CompletionProposal proposal = new CompletionProposal(this.completeString.substring(offsetInProposal), offset, 0, lastIndex);
	47	return new ICompletionProposal[] { proposal };
	48	}
	49	} catch (BadLocationException e) {
	50	e.printStackTrace();
	51	}
30	52	}
31	53	return new ICompletionProposal[0];
32		}
33
34		@Override
35		public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) {
36		return null;
37	54	}
38	55
39	56	@Override

46	63	return null;
47	64	}
48	65
	66	/**
	67	* Creates context info "idx= <word index in #PROPOSAL>" at the end of a word.
	68	**/
	69	@Override
	70	public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) {
	71	try {
	72	IDocument document= viewer.getDocument();
	73	int begin= offset;
	74	while (begin > 0 && Character.isLetterOrDigit(document.getChar(begin - 1))) {
	75	begin--;
	76	}
	77	if (begin < offset) {
	78	String word= document.get(begin, offset - begin);
	79	int idx= Arrays.asList(completeString.split("\\W")).indexOf(word);
	80	if (idx >= 0) {
	81	return new IContextInformation[] {
	82	new ContextInformation(word, "idx= " + idx)
	83	};
	84	}
	85	}
	86	} catch (BadLocationException e) {
	87	e.printStackTrace();
	88	}
	89	return null;
	90	}
	91
	92	@Override
	93	public IContextInformationValidator getContextInformationValidator() {
	94	return new IContextInformationValidator() {
	95	ITextViewer viewer;
	96	int offset;
	97	@Override
	98	public void install(IContextInformation info, ITextViewer viewer, int offset) {
	99	this.viewer= viewer;
	100	this.offset= offset;
	101	}
	102	@Override
	103	public boolean isContextInformationValid(int offset) {
	104	try {
	105	IDocument document= viewer.getDocument();
	106	IRegion line= document.getLineInformationOfOffset(this.offset);
	107	int end= line.getOffset() + line.getLength();
	108	return (offset >= this.offset && offset < end);
	109	} catch (BadLocationException e) {
	110	return false;
	111	}
	112	}
	113	};
	114	}
	115
49	116	@Override
50	117	public String getErrorMessage() {
51	118	return null;
52	119	}
53	120
54		@Override
55		public IContextInformationValidator getContextInformationValidator() {
56		return null;
57		}
58
59	121	}

+32

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/EnabledPropertyTester.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2018 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Lucas Bullen (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.core.expressions.PropertyTester;
	13
	14	public class EnabledPropertyTester extends PropertyTester {
	15
	16	private static final String PROPERTY_NAME = "enabled";
	17	private static boolean isEnabled = true;
	18
	19	@Override
	20	public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {
	21	if (property.equals(PROPERTY_NAME)) {
	22	return isEnabled;
	23	}
	24	return false;
	25	}
	26
	27	public static void setEnabled(boolean isEnabled) {
	28	EnabledPropertyTester.isEnabled = isEnabled;
	29	}
	30
	31	}

+38

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/HelloHoverProvider.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Mickael Istria (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.jface.text.IRegion;
	13	import org.eclipse.jface.text.ITextHover;
	14	import org.eclipse.jface.text.ITextHoverExtension2;
	15	import org.eclipse.jface.text.ITextViewer;
	16	import org.eclipse.jface.text.Region;
	17
	18	public class HelloHoverProvider implements ITextHover, ITextHoverExtension2 {
	19
	20	public static final String LABEL= "Hello!";
	21
	22	@Deprecated
	23	@Override
	24	public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {
	25	return null;
	26	}
	27
	28	@Override
	29	public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
	30	return new Region(0, textViewer.getTextWidget().getText().length());
	31	}
	32
	33	@Override
	34	public Object getHoverInfo2(ITextViewer textViewer, IRegion hoverRegion) {
	35	return LABEL;
	36	}
	37	}

+37

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/HighlightReconciler.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Lucas Bullen (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.jface.text.IDocument;
	13	import org.eclipse.jface.text.ITextViewer;
	14	import org.eclipse.jface.text.reconciler.Reconciler;
	15
	16	public class HighlightReconciler extends Reconciler {
	17
	18	private HighlightStrategy fStrategy;
	19
	20	public HighlightReconciler() {
	21	fStrategy = new HighlightStrategy();
	22	this.setReconcilingStrategy(fStrategy, IDocument.DEFAULT_CONTENT_TYPE);
	23	}
	24
	25	@Override
	26	public void install(ITextViewer textViewer) {
	27	super.install(textViewer);
	28	fStrategy.install(textViewer);
	29	}
	30
	31	@Override
	32	public void uninstall() {
	33	super.uninstall();
	34	fStrategy.uninstall();
	35	}
	36	}

+164

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/HighlightStrategy.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* - Lucas Bullen (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.swt.custom.CaretEvent;
	13	import org.eclipse.swt.custom.CaretListener;
	14
	15	import org.eclipse.core.runtime.IProgressMonitor;
	16	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
	17	import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
	18	import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;
	19	import org.eclipse.core.runtime.preferences.InstanceScope;
	20
	21	import org.eclipse.jface.text.IDocument;
	22	import org.eclipse.jface.text.IRegion;
	23	import org.eclipse.jface.text.ISynchronizable;
	24	import org.eclipse.jface.text.ITextViewer;
	25	import org.eclipse.jface.text.Position;
	26	import org.eclipse.jface.text.reconciler.DirtyRegion;
	27	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	28	import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
	29	import org.eclipse.jface.text.source.Annotation;
	30	import org.eclipse.jface.text.source.IAnnotationModel;
	31	import org.eclipse.jface.text.source.IAnnotationModelExtension;
	32	import org.eclipse.jface.text.source.ISourceViewer;
	33
	34	/**
	35	*
	36	* This Reconciler Strategy is an example for how to override the default highlight strategy.
	37	* It will highlight closing and opening tag names that match the current word the user is on.
	38	*
	39	*/
	40	public class HighlightStrategy implements IReconcilingStrategy, IReconcilingStrategyExtension, CaretListener, IPreferenceChangeListener {
	41
	42	private static final String ANNOTATION_TYPE = "org.eclipse.ui.genericeditor.text"; //$NON-NLS-1$
	43	public static final String TOGGLE_HIGHLIGHT_PREFERENCE = "org.eclipse.ui.genericeditor.togglehighlight"; //$NON-NLS-1$
	44	public static final String GENERIC_EDITOR_BUNDLE_ID = "org.eclipse.ui.genericeditor"; //$NON-NLS-1$
	45
	46	private boolean enabled;
	47	private ISourceViewer sourceViewer;
	48	private IDocument document;
	49
	50	public static final String SEARCH_TERM = "'bar'";
	51
	52	private Annotation[] fOccurrenceAnnotations = null;
	53
	54	private void applyHighlights() {
	55	if (sourceViewer == null \|\| !enabled) {
	56	return;
	57	}
	58
	59	removeOccurrenceAnnotations();
	60	int searchOffset = document.get().indexOf(SEARCH_TERM);
	61	if(searchOffset == -1) {
	62	return;
	63	}
	64	sourceViewer.getAnnotationModel().addAnnotation(new Annotation(ANNOTATION_TYPE, false, null),
	65	new Position(searchOffset, 5));
	66
	67	}
	68
	69	public void install(ITextViewer viewer) {
	70	if (!(viewer instanceof ISourceViewer)) {
	71	return;
	72	}
	73	IEclipsePreferences preferences = InstanceScope.INSTANCE.getNode(GENERIC_EDITOR_BUNDLE_ID);
	74	preferences.addPreferenceChangeListener(this);
	75	this.enabled = preferences.getBoolean(TOGGLE_HIGHLIGHT_PREFERENCE, true);
	76	this.sourceViewer = (ISourceViewer) viewer;
	77	this.sourceViewer.getTextWidget().addCaretListener(this);
	78	}
	79
	80	public void uninstall() {
	81	if (sourceViewer != null) {
	82	sourceViewer.getTextWidget().removeCaretListener(this);
	83	}
	84	IEclipsePreferences preferences = InstanceScope.INSTANCE.getNode(GENERIC_EDITOR_BUNDLE_ID);
	85	preferences.removePreferenceChangeListener(this);
	86	}
	87
	88	@Override
	89	public void preferenceChange(PreferenceChangeEvent event) {
	90	if (event.getKey().equals(TOGGLE_HIGHLIGHT_PREFERENCE)) {
	91	this.enabled = Boolean.parseBoolean(event.getNewValue().toString());
	92	if (enabled) {
	93	initialReconcile();
	94	} else {
	95	removeOccurrenceAnnotations();
	96	}
	97	}
	98	}
	99
	100	@Override
	101	public void caretMoved(CaretEvent event) {
	102	applyHighlights();
	103	}
	104
	105	@Override
	106	public void initialReconcile() {
	107	if (sourceViewer != null) {
	108	sourceViewer.getTextWidget().getDisplay().asyncExec(() -> {
	109	if (sourceViewer != null && sourceViewer.getTextWidget() != null) {
	110	applyHighlights();
	111	}
	112	});
	113	}
	114	}
	115
	116	void removeOccurrenceAnnotations() {
	117	IAnnotationModel annotationModel = sourceViewer.getAnnotationModel();
	118	if (annotationModel == null \|\| fOccurrenceAnnotations == null) {
	119	return;
	120	}
	121
	122	synchronized (getLockObject(annotationModel)) {
	123	if (annotationModel instanceof IAnnotationModelExtension) {
	124	((IAnnotationModelExtension) annotationModel).replaceAnnotations(fOccurrenceAnnotations, null);
	125	} else {
	126	for (Annotation fOccurrenceAnnotation : fOccurrenceAnnotations) {
	127	annotationModel.removeAnnotation(fOccurrenceAnnotation);
	128	}
	129	}
	130	fOccurrenceAnnotations = null;
	131	}
	132	}
	133
	134	private static Object getLockObject(IAnnotationModel annotationModel) {
	135	if (annotationModel instanceof ISynchronizable) {
	136	Object lock = ((ISynchronizable) annotationModel).getLockObject();
	137	if (lock != null) {
	138	return lock;
	139	}
	140	}
	141	return annotationModel;
	142	}
	143
	144	@Override
	145	public void setDocument(IDocument document) {
	146	this.document = document;
	147	}
	148
	149	@Override
	150	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	151	// Do nothing
	152	}
	153
	154	@Override
	155	public void reconcile(IRegion partition) {
	156	// Do nothing
	157	}
	158
	159	@Override
	160	public void setProgressMonitor(IProgressMonitor monitor) {
	161	// Not used
	162	}
	163	}

+7

-39

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/LongRunningBarContentAssistProcessor.java less more

10	10	package org.eclipse.ui.genericeditor.tests.contributions;
11	11
12	12	import org.eclipse.jface.text.ITextViewer;
13		import org.eclipse.jface.text.contentassist.CompletionProposal;
14	13	import org.eclipse.jface.text.contentassist.ICompletionProposal;
15		import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
16		import org.eclipse.jface.text.contentassist.IContextInformation;
17		import org.eclipse.jface.text.contentassist.IContextInformationValidator;
18	14
19		public class LongRunningBarContentAssistProcessor implements IContentAssistProcessor {
	15	public class LongRunningBarContentAssistProcessor extends BarContentAssistProcessor {
20	16
21		public static final String PROPOSAL = "s are also good for soft drink cocktails.";
	17	public static final String PROPOSAL = "bars are also good for soft drink cocktails.";
22	18	public static final int DELAY = 2000;
	19
	20	public LongRunningBarContentAssistProcessor() {
	21	super(PROPOSAL);
	22	}
23	23
24	24	@Override
25	25	public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {

29	29	// TODO Auto-generated catch block
30	30	e.printStackTrace();
31	31	}
32		String text = viewer.getDocument().get();
33		if (text.length() >= 3 && text.substring(offset - 3, offset).equals("bar")) {
34		String message = PROPOSAL;
35		CompletionProposal proposal = new CompletionProposal(message, offset, 0, message.length());
36		return new ICompletionProposal[] { proposal };
37		}
38		return new ICompletionProposal[0];
	32	return super.computeCompletionProposals(viewer, offset);
39	33	}
40
41		@Override
42		public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) {
43		return null;
44		}
45
46		@Override
47		public char[] getCompletionProposalAutoActivationCharacters() {
48		return null;
49		}
50
51		@Override
52		public char[] getContextInformationAutoActivationCharacters() {
53		return null;
54		}
55
56		@Override
57		public String getErrorMessage() {
58		return null;
59		}
60
61		@Override
62		public IContextInformationValidator getContextInformationValidator() {
63		return null;
64		}
65
66	34	}

+0

-39

~~org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/MagicHoverProvider.java~~ less more

0		/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others
2		* All rights reserved. This program and the accompanying materials
3		* are made available under the terms of the Eclipse Public License v1.0
4		* which accompanies this distribution, and is available at
5		* http://www.eclipse.org/legal/epl-v10.html
6		*
7		* Contributors:
8		* Mickael Istria (Red Hat Inc.)
9		*******************************************************************************/
10		package org.eclipse.ui.genericeditor.tests.contributions;
11
12		import org.eclipse.jface.text.IRegion;
13		import org.eclipse.jface.text.ITextHover;
14		import org.eclipse.jface.text.ITextHoverExtension2;
15		import org.eclipse.jface.text.ITextViewer;
16		import org.eclipse.jface.text.Region;
17
18		public class MagicHoverProvider implements ITextHover,ITextHoverExtension2 {
19
20		public static final String LABEL= "Alrighty!";
21
22		@Deprecated
23		@Override
24		public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {
25		return null;
26		}
27
28		@Override
29		public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
30		return new Region(0, textViewer.getTextWidget().getText().length());
31		}
32
33		@Override
34		public Object getHoverInfo2(ITextViewer textViewer, IRegion hoverRegion) {
35		return LABEL;
36		}
37
38		}

+59

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/ReconcilerStrategyFirst.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.swt.widgets.Display;
	13
	14	import org.eclipse.core.runtime.IProgressMonitor;
	15
	16	import org.eclipse.jface.text.IDocument;
	17	import org.eclipse.jface.text.IRegion;
	18	import org.eclipse.jface.text.reconciler.DirtyRegion;
	19	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	20	import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
	21
	22	public class ReconcilerStrategyFirst implements IReconcilingStrategy, IReconcilingStrategyExtension{
	23
	24	IDocument document;
	25	public static final String SEARCH_TERM = "foo";
	26	public static final String REPLACEMENT = "BAR";
	27
	28	@Override
	29	public void setDocument(IDocument document) {
	30	this.document = document;
	31	}
	32
	33	@Override
	34	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	35	initialReconcile();
	36	}
	37
	38	@Override
	39	public void reconcile(IRegion partition) {
	40	initialReconcile();
	41	}
	42
	43	@Override
	44	public void setProgressMonitor(IProgressMonitor monitor) {
	45	// no progress monitor in use
	46	}
	47
	48	@Override
	49	public void initialReconcile() {
	50	String doc = document.get();
	51	if(doc.contains(SEARCH_TERM)) {
	52	Display.getDefault().asyncExec(() -> {
	53	document.set(document.get().replaceAll(SEARCH_TERM, REPLACEMENT));
	54	});
	55	}
	56	}
	57
	58	}

+59

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/ReconcilerStrategySecond.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.swt.widgets.Display;
	13
	14	import org.eclipse.core.runtime.IProgressMonitor;
	15
	16	import org.eclipse.jface.text.IDocument;
	17	import org.eclipse.jface.text.IRegion;
	18	import org.eclipse.jface.text.reconciler.DirtyRegion;
	19	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	20	import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
	21
	22	public class ReconcilerStrategySecond implements IReconcilingStrategy, IReconcilingStrategyExtension{
	23
	24	IDocument document;
	25	public static final String SEARCH_TERM = "BAR";
	26	public static final String REPLACEMENT = "second";
	27
	28	@Override
	29	public void setDocument(IDocument document) {
	30	this.document = document;
	31	}
	32
	33	@Override
	34	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
	35	initialReconcile();
	36	}
	37
	38	@Override
	39	public void reconcile(IRegion partition) {
	40	initialReconcile();
	41	}
	42
	43	@Override
	44	public void setProgressMonitor(IProgressMonitor monitor) {
	45	// no progress monitor in use
	46	}
	47
	48	@Override
	49	public void initialReconcile() {
	50	String doc = document.get();
	51	if(doc.contains(SEARCH_TERM)) {
	52	Display.getDefault().asyncExec(() -> {
	53	document.set(document.get().replaceAll(SEARCH_TERM, REPLACEMENT));
	54	});
	55	}
	56	}
	57
	58	}

+24

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/TheAutoEditStrategyFirst.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Rogue Wave Software Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Michał Niewrzał (Rogue Wave Software Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.jface.text.DocumentCommand;
	13	import org.eclipse.jface.text.IAutoEditStrategy;
	14	import org.eclipse.jface.text.IDocument;
	15
	16	public class TheAutoEditStrategyFirst implements IAutoEditStrategy {
	17
	18	@Override
	19	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
	20	command.text = command.text + "AutoAddedFirst!";
	21	}
	22
	23	}

+24

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/TheAutoEditStrategySecond.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Rogue Wave Software Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Michał Niewrzał (Rogue Wave Software Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.jface.text.DocumentCommand;
	13	import org.eclipse.jface.text.IAutoEditStrategy;
	14	import org.eclipse.jface.text.IDocument;
	15
	16	public class TheAutoEditStrategySecond implements IAutoEditStrategy {
	17
	18	@Override
	19	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
	20	command.text = command.text + "AutoAddedSecond!";
	21	}
	22
	23	}

+24

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/TheAutoEditStrategyThird.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Rogue Wave Software Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Michał Niewrzał (Rogue Wave Software Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.jface.text.DocumentCommand;
	13	import org.eclipse.jface.text.IAutoEditStrategy;
	14	import org.eclipse.jface.text.IDocument;
	15
	16	public class TheAutoEditStrategyThird implements IAutoEditStrategy {
	17
	18	@Override
	19	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
	20	command.text = command.text + "AutoAddedThird!";
	21	}
	22
	23	}

+0

-38

~~org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/ThePresentationReconciler.java~~ less more

0		/*******************************************************************************
1		* Copyright (c) 2016 Red Hat Inc. and others
2		* All rights reserved. This program and the accompanying materials
3		* are made available under the terms of the Eclipse Public License v1.0
4		* which accompanies this distribution, and is available at
5		* http://www.eclipse.org/legal/epl-v10.html
6		*
7		* Contributors:
8		* Sopot Cela (Red Hat Inc.)
9		*******************************************************************************/
10		package org.eclipse.ui.genericeditor.tests.contributions;
11
12		import org.eclipse.swt.graphics.Color;
13		import org.eclipse.swt.graphics.RGB;
14		import org.eclipse.swt.widgets.Display;
15
16		import org.eclipse.jface.text.IDocument;
17		import org.eclipse.jface.text.TextAttribute;
18		import org.eclipse.jface.text.presentation.PresentationReconciler;
19		import org.eclipse.jface.text.rules.DefaultDamagerRepairer;
20		import org.eclipse.jface.text.rules.IRule;
21		import org.eclipse.jface.text.rules.RuleBasedScanner;
22		import org.eclipse.jface.text.rules.SingleLineRule;
23		import org.eclipse.jface.text.rules.Token;
24
25		public class ThePresentationReconciler extends PresentationReconciler {
26
27		public ThePresentationReconciler() {
28		RuleBasedScanner scanner= new RuleBasedScanner();
29		IRule[] rules = new IRule[1];
30		rules[0]= new SingleLineRule("'", "'", new Token(new TextAttribute(new Color(Display.getCurrent(), new RGB(255, 0, 0))))); //$NON-NLS-1$ //$NON-NLS-2$
31		scanner.setRules(rules);
32		DefaultDamagerRepairer dr= new DefaultDamagerRepairer(scanner);
33		this.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);
34		this.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);
35		}
36
37		}

+38

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/ThePresentationReconcilerBlue.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2016 Red Hat Inc. and others
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Sopot Cela (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.swt.graphics.Color;
	13	import org.eclipse.swt.graphics.RGB;
	14	import org.eclipse.swt.widgets.Display;
	15
	16	import org.eclipse.jface.text.IDocument;
	17	import org.eclipse.jface.text.TextAttribute;
	18	import org.eclipse.jface.text.presentation.PresentationReconciler;
	19	import org.eclipse.jface.text.rules.DefaultDamagerRepairer;
	20	import org.eclipse.jface.text.rules.IRule;
	21	import org.eclipse.jface.text.rules.RuleBasedScanner;
	22	import org.eclipse.jface.text.rules.SingleLineRule;
	23	import org.eclipse.jface.text.rules.Token;
	24
	25	public class ThePresentationReconcilerBlue extends PresentationReconciler {
	26
	27	public ThePresentationReconcilerBlue() {
	28	RuleBasedScanner scanner= new RuleBasedScanner();
	29	IRule[] rules = new IRule[1];
	30	rules[0]= new SingleLineRule("'", "'", new Token(new TextAttribute(new Color(Display.getCurrent(), new RGB(0, 0, 255))))); //$NON-NLS-1$ //$NON-NLS-2$
	31	scanner.setRules(rules);
	32	DefaultDamagerRepairer dr= new DefaultDamagerRepairer(scanner);
	33	this.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);
	34	this.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);
	35	}
	36
	37	}

+42

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/ThePresentationReconcilerGreen.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2016-2017 Red Hat Inc. and others
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Sopot Cela (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.swt.graphics.Color;
	13	import org.eclipse.swt.graphics.RGB;
	14	import org.eclipse.swt.widgets.Display;
	15
	16	import org.eclipse.jface.text.IDocument;
	17	import org.eclipse.jface.text.TextAttribute;
	18	import org.eclipse.jface.text.presentation.PresentationReconciler;
	19	import org.eclipse.jface.text.rules.DefaultDamagerRepairer;
	20	import org.eclipse.jface.text.rules.IRule;
	21	import org.eclipse.jface.text.rules.RuleBasedScanner;
	22	import org.eclipse.jface.text.rules.SingleLineRule;
	23	import org.eclipse.jface.text.rules.Token;
	24
	25	/**
	26	* This presentation reconciler is associated to a more "basic" content-type so it
	27	* shouldn't be used.
	28	*/
	29	public class ThePresentationReconcilerGreen extends PresentationReconciler {
	30
	31	public ThePresentationReconcilerGreen() {
	32	RuleBasedScanner scanner= new RuleBasedScanner();
	33	IRule[] rules = new IRule[1];
	34	rules[0]= new SingleLineRule("'", "'", new Token(new TextAttribute(new Color(Display.getCurrent(), new RGB(0, 255, 0))))); //$NON-NLS-1$ //$NON-NLS-2$
	35	scanner.setRules(rules);
	36	DefaultDamagerRepairer dr= new DefaultDamagerRepairer(scanner);
	37	this.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);
	38	this.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);
	39	}
	40
	41	}

+38

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/ThePresentationReconcilerRed.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2016 Red Hat Inc. and others
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Sopot Cela (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.swt.graphics.Color;
	13	import org.eclipse.swt.graphics.RGB;
	14	import org.eclipse.swt.widgets.Display;
	15
	16	import org.eclipse.jface.text.IDocument;
	17	import org.eclipse.jface.text.TextAttribute;
	18	import org.eclipse.jface.text.presentation.PresentationReconciler;
	19	import org.eclipse.jface.text.rules.DefaultDamagerRepairer;
	20	import org.eclipse.jface.text.rules.IRule;
	21	import org.eclipse.jface.text.rules.RuleBasedScanner;
	22	import org.eclipse.jface.text.rules.SingleLineRule;
	23	import org.eclipse.jface.text.rules.Token;
	24
	25	public class ThePresentationReconcilerRed extends PresentationReconciler {
	26
	27	public ThePresentationReconcilerRed() {
	28	RuleBasedScanner scanner= new RuleBasedScanner();
	29	IRule[] rules = new IRule[1];
	30	rules[0]= new SingleLineRule("'", "'", new Token(new TextAttribute(new Color(Display.getCurrent(), new RGB(255, 0, 0))))); //$NON-NLS-1$ //$NON-NLS-2$
	31	scanner.setRules(rules);
	32	DefaultDamagerRepairer dr= new DefaultDamagerRepairer(scanner);
	33	this.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);
	34	this.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);
	35	}
	36
	37	}

+20

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/TheReconcilerFirst.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.jface.text.IDocument;
	13	import org.eclipse.jface.text.reconciler.Reconciler;
	14
	15	public class TheReconcilerFirst extends Reconciler{
	16	public TheReconcilerFirst() {
	17	this.setReconcilingStrategy(new ReconcilerStrategyFirst(), IDocument.DEFAULT_CONTENT_TYPE);
	18	}
	19	}

+20

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/TheReconcilerSecond.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.) - initial implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.jface.text.IDocument;
	13	import org.eclipse.jface.text.reconciler.Reconciler;
	14
	15	public class TheReconcilerSecond extends Reconciler{
	16	public TheReconcilerSecond() {
	17	this.setReconcilingStrategy(new ReconcilerStrategySecond(), IDocument.DEFAULT_CONTENT_TYPE);
	18	}
	19	}

+39

-0

org.eclipse.ui.genericeditor.tests/src/org/eclipse/ui/genericeditor/tests/contributions/WorldHoverProvider.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 Red Hat Inc. and others
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Lucas Bullen (Red Hat Inc.)
	9	*******************************************************************************/
	10	package org.eclipse.ui.genericeditor.tests.contributions;
	11
	12	import org.eclipse.jface.text.IRegion;
	13	import org.eclipse.jface.text.ITextHover;
	14	import org.eclipse.jface.text.ITextHoverExtension2;
	15	import org.eclipse.jface.text.ITextViewer;
	16	import org.eclipse.jface.text.Region;
	17
	18	public class WorldHoverProvider implements ITextHover,ITextHoverExtension2 {
	19
	20	public static final String LABEL= "World!";
	21
	22	@Deprecated
	23	@Override
	24	public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {
	25	return null;
	26	}
	27
	28	@Override
	29	public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
	30	return new Region(0, textViewer.getTextWidget().getText().length());
	31	}
	32
	33	@Override
	34	public Object getHoverInfo2(ITextViewer textViewer, IRegion hoverRegion) {
	35	return LABEL;
	36	}
	37
	38	}

+3

-3

org.eclipse.ui.workbench.texteditor/.settings/org.eclipse.jdt.ui.prefs less more

11	11	org.eclipse.jdt.ui.staticondemandthreshold=99
12	12	sp_cleanup.add_default_serial_version_id=false
13	13	sp_cleanup.add_generated_serial_version_id=false
14		sp_cleanup.add_missing_annotations=false
	14	sp_cleanup.add_missing_annotations=true
15	15	sp_cleanup.add_missing_deprecated_annotations=true
16	16	sp_cleanup.add_missing_methods=false
17	17	sp_cleanup.add_missing_nls_tags=false

43	43	sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
44	44	sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
45	45	sp_cleanup.remove_private_constructors=false
46		sp_cleanup.remove_redundant_type_arguments=false
	46	sp_cleanup.remove_redundant_type_arguments=true
47	47	sp_cleanup.remove_trailing_whitespaces=true
48	48	sp_cleanup.remove_trailing_whitespaces_all=true
49	49	sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
50		sp_cleanup.remove_unnecessary_casts=false
	50	sp_cleanup.remove_unnecessary_casts=true
51	51	sp_cleanup.remove_unnecessary_nls_tags=false
52	52	sp_cleanup.remove_unused_imports=false
53	53	sp_cleanup.remove_unused_local_variables=false

+4

-1

org.eclipse.ui.workbench.texteditor/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %pluginName
3	3	Bundle-SymbolicName: org.eclipse.ui.workbench.texteditor; singleton:=true
4		Bundle-Version: 3.10.100.qualifier
	4	Bundle-Version: 3.11.0.qualifier
5	5	Bundle-Activator: org.eclipse.ui.internal.texteditor.TextEditorPlugin
6	6	Bundle-ActivationPolicy: lazy
7	7	Bundle-Vendor: %providerName

9	9	Export-Package:
10	10	org.eclipse.ui.contentassist,
11	11	org.eclipse.ui.internal.texteditor; texteditor="split"; mandatory:="texteditor"; x-friends:="org.eclipse.ui.editors",
	12	org.eclipse.ui.internal.texteditor.codemining;x-internal:=true,
12	13	org.eclipse.ui.internal.texteditor.quickdiff;x-internal:=true,
13	14	org.eclipse.ui.internal.texteditor.quickdiff.compare.equivalence;x-internal:=true,
14	15	org.eclipse.ui.internal.texteditor.rulers;x-internal:=true,

24	25	org.eclipse.compare.core;bundle-version="[3.5.0,4.0.0)",
25	26	org.eclipse.core.expressions;bundle-version="[3.4.100,4.0.0)",
26	27	org.eclipse.jface.text;bundle-version="[3.8.0,4.0.0)",
	28	org.eclipse.swt;bundle-version="[3.107.0,4.0.0)",
27	29	org.eclipse.ui;bundle-version="[3.5.0,4.0.0)"
28	30	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
29	31	Import-Package: com.ibm.icu.text
	32	Automatic-Module-Name: org.eclipse.ui.workbench.texteditor

org.eclipse.ui.workbench.texteditor/icons/full/dtool16/block_selection_mode.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/dtool16/block_selection_mode@2x.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/dtool16/show_whitespace_chars.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/dtool16/show_whitespace_chars@2x.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/dtool16/wordwrap.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/dtool16/wordwrap@2x.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/etool16/block_selection_mode.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/etool16/block_selection_mode@2x.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/etool16/show_whitespace_chars.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/etool16/show_whitespace_chars@2x.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/etool16/wordwrap.png less more

Binary diff not shown

org.eclipse.ui.workbench.texteditor/icons/full/etool16/wordwrap@2x.png less more

Binary diff not shown

+5

-0

org.eclipse.ui.workbench.texteditor/plugin.properties less more

9	9	# Tom Eicher (Avaloq Evolution AG) - block selection mode
10	10	# Daesung Ha <nberserk@gmail.com> - update recenter command description
11	11	# Mickael Istria (Red Hat Inc.) - 469918 Zoom In/Out
	12	# Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide extension point for CodeMining - Bug 528419
12	13	###############################################################################
13	14	pluginName= Text Editor Framework
14	15	providerName= Eclipse.org

20	21	ExtPoint.rulerColumns= Ruler Columns
21	22	ExtPoint.hyperlinkDetectors= Hyperlink Detectors
22	23	ExtPoint.hyperlinkDetectorTargets= Hyperlink Detector Targets
	24	ExtPoint.codeMiningProviders=CodeMining Providers
23	25
24	26	textEditorPresentationActionSet.label= Editor Presentation
25	27

183	185	command.openHyperlink.name= Open Hyperlink
184	186	command.openHyperlink.description= Opens the hyperlink at the caret location or opens a chooser if more than one hyperlink is available
185	187
	188	Color.rangeIndicator= Range indicator color
	189	Color.rangeIndicatorDesc= The color that is used for the ruler that marks the range of the current selected text block.
	190
186	191	SpellingEngine= Spelling Engine
187	192
188	193	blockSelectionModeFont.label= Text Editor Block Selection Font

+10

-14

org.eclipse.ui.workbench.texteditor/plugin.xml less more

6	6	<extension-point id="rulerColumns" name="%ExtPoint.rulerColumns" schema="schema/rulerColumns.exsd"/>
7	7	<extension-point id="hyperlinkDetectors" name="%ExtPoint.hyperlinkDetectors" schema="schema/hyperlinkDetectors.exsd"/>
8	8	<extension-point id="hyperlinkDetectorTargets" name="%ExtPoint.hyperlinkDetectorTargets" schema="schema/hyperlinkDetectorTargets.exsd"/>
	9	<extension-point id="codeMiningProviders" name="%ExtPoint.codeMiningProviders" schema="schema/codeMiningProviders.exsd"/>
9	10
10	11	<extension
11	12	point="org.eclipse.ui.commands">

1300	1301	value="Monaco-regular-11">
1301	1302	</fontValue>
1302	1303	</fontDefinition>
	1304	<colorDefinition
	1305	categoryId="org.eclipse.ui.workbenchMisc"
	1306	id="org.eclipse.ui.editors.rangeIndicatorColor"
	1307	label="%Color.rangeIndicator"
	1308	value="COLOR_LIST_SELECTION">
	1309	<description>
	1310	%Color.rangeIndicatorDesc
	1311	</description>
	1312	</colorDefinition>
1303	1313	</extension>
1304	1314
1305	1315	<extension

1307	1317	<handler
1308	1318	class="org.eclipse.ui.texteditor.TextZoomInHandler"
1309	1319	commandId="org.eclipse.ui.edit.text.zoomIn">
1310		<enabledWhen>
1311		<with variable="activePart">
1312		<instanceof
1313		value="org.eclipse.ui.texteditor.ITextEditor">
1314		</instanceof>
1315		</with>
1316		</enabledWhen>
1317	1320	</handler>
1318	1321	<handler
1319	1322	class="org.eclipse.ui.texteditor.TextZoomOutHandler"
1320	1323	commandId="org.eclipse.ui.edit.text.zoomOut">
1321		<enabledWhen>
1322		<with variable="activePart">
1323		<instanceof
1324		value="org.eclipse.ui.texteditor.ITextEditor">
1325		</instanceof>
1326		</with>
1327		</enabledWhen>
1328	1324	</handler>
1329	1325	</extension>
1330	1326	<extension

+3

-3

org.eclipse.ui.workbench.texteditor/pom.xml less more

0	0	<?xml version="1.0" encoding="UTF-8"?>
1	1	<!--
2		Copyright (c) 2012, 2016 Eclipse Foundation and others.
	2	Copyright (c) 2012, 2018 Eclipse Foundation and others.
3	3	All rights reserved. This program and the accompanying materials
4	4	are made available under the terms of the Eclipse Distribution License v1.0
5	5	which accompanies this distribution, and is available at

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<groupId>org.eclipse.ui</groupId>
19	19	<artifactId>org.eclipse.ui.workbench.texteditor</artifactId>
20		<version>3.10.100-SNAPSHOT</version>
	20	<version>3.11.0-SNAPSHOT</version>
21	21	<packaging>eclipse-plugin</packaging>
22	22	</project>

+171

-0

org.eclipse.ui.workbench.texteditor/schema/codeMiningProviders.exsd less more

	0	<?xml version='1.0' encoding='UTF-8'?>
	1	<!-- Schema file written by PDE -->
	2	<schema targetNamespace="org.eclipse.ui.workbench.texteditor" xmlns="http://www.w3.org/2001/XMLSchema">
	3	<annotation>
	4	<appInfo>
	5	<meta.schema plugin="org.eclipse.ui.workbench.texteditor" id="codeMiningProviders" name="CodeMining Providers"/>
	6	</appInfo>
	7	<documentation>
	8	This extension point is used to register codemining providers. Associating providers via this extension doesn't automatically enable code-mining, and that clients are also supposed to use a reconcilier or whatever event mechanism to invoke ISourceViewerExtension5.updateCodeMinings().
	9	</documentation>
	10	</annotation>
	11
	12	<include schemaLocation="schema://org.eclipse.core.expressions/schema/expressionLanguage.exsd"/>
	13
	14	<element name="extension">
	15	<annotation>
	16	<appInfo>
	17	<meta.element />
	18	</appInfo>
	19	</annotation>
	20	<complexType>
	21	<sequence>
	22	<element ref="codeMiningProvider" minOccurs="1" maxOccurs="unbounded"/>
	23	</sequence>
	24	<attribute name="point" type="string" use="required">
	25	<annotation>
	26	<documentation>
	27	a fully qualified identifier of the target extension point
	28	</documentation>
	29	</annotation>
	30	</attribute>
	31	<attribute name="id" type="string">
	32	<annotation>
	33	<documentation>
	34	an optional identifier of the extension instance
	35	</documentation>
	36	</annotation>
	37	</attribute>
	38	<attribute name="name" type="string">
	39	<annotation>
	40	<documentation>
	41	an optional name of the extension instance
	42	</documentation>
	43	<appInfo>
	44	<meta.attribute translatable="true"/>
	45	</appInfo>
	46	</annotation>
	47	</attribute>
	48	</complexType>
	49	</element>
	50
	51	<element name="codeMiningProvider">
	52	<annotation>
	53	<documentation>
	54	A CodeMining provider.
	55	</documentation>
	56	</annotation>
	57	<complexType>
	58	<sequence>
	59	<element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
	60	</sequence>
	61	<attribute name="id" type="string" use="required">
	62	<annotation>
	63	<documentation>
	64	a string uniquely identifying this codemining provider
	65	</documentation>
	66	</annotation>
	67	</attribute>
	68	<attribute name="class" type="string" use="required">
	69	<annotation>
	70	<documentation>
	71	the fully qualified class name implementing the interface <code>org.eclipse.jface.text.codemining.ICodeMiningProvider</code>.
	72	</documentation>
	73	<appInfo>
	74	<meta.attribute kind="java" basedOn=":org.eclipse.jface.text.codemining.ICodeMiningProvider"/>
	75	</appInfo>
	76	</annotation>
	77	</attribute>
	78	<attribute name="label" type="string">
	79	<annotation>
	80	<documentation>
	81	the display label for the codemining provider, which will show in the CodeMining UI preferences
	82	</documentation>
	83	<appInfo>
	84	<meta.attribute translatable="true"/>
	85	</appInfo>
	86	</annotation>
	87	</attribute>
	88	</complexType>
	89	</element>
	90
	91	<element name="enabledWhen">
	92	<annotation>
	93	<documentation>
	94	A core Expression that controls the enabled of the given codemining provider
	95	</documentation>
	96	</annotation>
	97	<complexType>
	98	<choice minOccurs="0" maxOccurs="1">
	99	<element ref="not"/>
	100	<element ref="or"/>
	101	<element ref="and"/>
	102	<element ref="instanceof"/>
	103	<element ref="test"/>
	104	<element ref="systemTest"/>
	105	<element ref="equals"/>
	106	<element ref="count"/>
	107	<element ref="with"/>
	108	<element ref="resolve"/>
	109	<element ref="adapt"/>
	110	<element ref="iterate"/>
	111	<element ref="reference"/>
	112	</choice>
	113	</complexType>
	114	</element>
	115
	116	<annotation>
	117	<appInfo>
	118	<meta.section type="since"/>
	119	</appInfo>
	120	<documentation>
	121	3.10
	122	</documentation>
	123	</annotation>
	124
	125	<annotation>
	126	<appInfo>
	127	<meta.section type="examples"/>
	128	</appInfo>
	129	<documentation>
	130	The following is an example of a codemining provider definition:
	131
	132	<pre>
	133	<extension
	134	point="org.eclipse.ui.workbench.texteditor.codeMiningProviders">
	135	<codeMiningProvider
	136	class="org.eclipse.jdt.internal.ui.codemining.JavaReferencesCodeMiningProvider"
	137	id="org.eclipse.jdt.ui.codemining.references"
	138	label="Java References">
	139	<enabledWhen>
	140	<with variable="editor">
	141	<instanceof value="org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor"/>
	142	</with>
	143	</enabledWhen>
	144	</codeMiningProvider>
	145	</extension>
	146	</pre>
	147	</documentation>
	148	</annotation>
	149
	150	<annotation>
	151	<appInfo>
	152	<meta.section type="apiInfo"/>
	153	</appInfo>
	154	<documentation>
	155	See the org.eclipse.jface.text.codemining.ICodeMiningProvider class and the org.eclipse.ui.workbench.texteditor.codeMiningProviders extension point.
	156	</documentation>
	157	</annotation>
	158
	159
	160	<annotation>
	161	<appInfo>
	162	<meta.section type="copyright"/>
	163	</appInfo>
	164	<documentation>
	165	Copyright (c) 2017 Angelo ZERR.<br>
	166	All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
	167	</documentation>
	168	</annotation>
	169
	170	</schema>

+1

-1

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/internal/texteditor/HippieCompletionEngine.java less more

104	104	* @return the string converted to a regex pattern
105	105	*/
106	106	private String asRegPattern(CharSequence string) {
107		StringBuffer out= new StringBuffer(string.length());
	107	StringBuilder out= new StringBuilder(string.length());
108	108	boolean quoting= false;
109	109
110	110	for (int i= 0, length= string.length(); i < length; i++) {

+25

-0

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/internal/texteditor/TextEditorPlugin.java less more

6	6	*
7	7	* Contributors:
8	8	* IBM Corporation - initial API and implementation
	9	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide extension point for CodeMining - Bug 528419
9	10	*******************************************************************************/
10	11	package org.eclipse.ui.internal.texteditor;
11	12

22	23
23	24	import org.eclipse.jface.action.IAction;
24	25
	26	import org.eclipse.ui.internal.texteditor.codemining.CodeMiningProviderRegistry;
25	27	import org.eclipse.ui.internal.texteditor.quickdiff.QuickDiffExtensionsRegistry;
26	28	import org.eclipse.ui.internal.texteditor.spelling.SpellingEngineRegistry;
27	29	import org.eclipse.ui.plugin.AbstractUIPlugin;

62	64	private SpellingEngineRegistry fSpellingEngineRegistry;
63	65
64	66	/**
	67	* The codemining provider registry
	68	*
	69	* @since 3.10
	70	*/
	71	private CodeMiningProviderRegistry fCodeMiningProviderRegistry;
	72
	73	/**
65	74	* Creates a plug-in instance.
66	75	*/
67	76	public TextEditorPlugin() {

149	158	super.start(context);
150	159	fQuickDiffExtensionRegistry= new QuickDiffExtensionsRegistry();
151	160	fSpellingEngineRegistry= new SpellingEngineRegistry();
	161	fCodeMiningProviderRegistry = new CodeMiningProviderRegistry();
152	162	Platform.getExtensionRegistry().addRegistryChangeListener(this, PLUGIN_ID);
153	163	}
154	164

157	167	Platform.getExtensionRegistry().removeRegistryChangeListener(this);
158	168	fQuickDiffExtensionRegistry= null;
159	169	fSpellingEngineRegistry= null;
	170	fCodeMiningProviderRegistry = null;
160	171	super.stop(context);
161	172	}
162	173

166	177	fQuickDiffExtensionRegistry.reloadExtensions();
167	178	if (fSpellingEngineRegistry != null && event.getExtensionDeltas(PLUGIN_ID, SpellingEngineRegistry.SPELLING_ENGINE_EXTENSION_POINT).length > 0)
168	179	fSpellingEngineRegistry.reloadExtensions();
	180	if (fCodeMiningProviderRegistry != null && event.getExtensionDeltas(PLUGIN_ID,
	181	CodeMiningProviderRegistry.CODEMINING_PROVIDERS_EXTENSION_POINT).length > 0)
	182	fCodeMiningProviderRegistry.reloadExtensions();
169	183	}
170	184
171	185	/**

187	201	public SpellingEngineRegistry getSpellingEngineRegistry() {
188	202	return fSpellingEngineRegistry;
189	203	}
	204
	205	/**
	206	* Returns this plug-ins codemining provider registry.
	207	*
	208	* @return the codemining provider registry or <code>null</code> if this plug-in
	209	* has been shutdown
	210	* @since 3.10
	211	*/
	212	public CodeMiningProviderRegistry getCodeMiningProviderRegistry() {
	213	return fCodeMiningProviderRegistry;
	214	}
190	215	}

+193

-0

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/internal/texteditor/codemining/CodeMiningProviderDescriptor.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide extension point for CodeMining - Bug 528419
	9	*/
	10	package org.eclipse.ui.internal.texteditor.codemining;
	11
	12	import org.eclipse.core.expressions.ElementHandler;
	13	import org.eclipse.core.expressions.EvaluationContext;
	14	import org.eclipse.core.expressions.EvaluationResult;
	15	import org.eclipse.core.expressions.Expression;
	16	import org.eclipse.core.expressions.ExpressionConverter;
	17
	18	import org.eclipse.core.runtime.Assert;
	19	import org.eclipse.core.runtime.CoreException;
	20	import org.eclipse.core.runtime.IConfigurationElement;
	21	import org.eclipse.core.runtime.IStatus;
	22	import org.eclipse.core.runtime.Status;
	23
	24	import org.eclipse.jface.text.codemining.AbstractCodeMiningProvider;
	25	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
	26	import org.eclipse.jface.text.source.ISourceViewer;
	27
	28	import org.eclipse.ui.internal.texteditor.TextEditorPlugin;
	29
	30	import org.eclipse.ui.texteditor.ITextEditor;
	31
	32	/**
	33	* Describes an extension to the <code>codeMiningProviders</code> extension
	34	* point.
	35	* <p>
	36	* This class is not intended to be subclassed by clients.
	37	* </p>
	38	*
	39	* @since 3.10
	40	* @noextend This class is not intended to be subclassed by clients.
	41	*/
	42	class CodeMiningProviderDescriptor {
	43
	44	/** Name of the <code>label</code> attribute. */
	45	private static final String LABEL_ATTRIBUTE = "label"; //$NON-NLS-1$
	46	/** Name of the <code>class</code> attribute. */
	47	private static final String CLASS_ATTRIBUTE = "class"; //$NON-NLS-1$
	48	/** Name of the <code>id</code> attribute. */
	49	private static final String ID_ATTRIBUTE = "id"; //$NON-NLS-1$
	50	/ Name of the <code>enabledWhen</code> attribute. /
	51	private static final String ENABLED_WHEN_ATTR = "enabledWhen"; //$NON-NLS-1$
	52
	53	/** The configuration element describing this extension. */
	54	private IConfigurationElement fConfiguration;
	55	/** The value of the <code>label</code> attribute, if read. */
	56	private String fLabel;
	57	/** The value of the <code>id</code> attribute, if read. */
	58	private String fId;
	59	/** The expression value of the <code>enabledWhen</code> attribute. */
	60	private final Expression fEnabledWhen;
	61
	62	/**
	63	* Creates a new descriptor for <code>element</code>.
	64	* <p>
	65	* This method is for internal use only.
	66	* </p>
	67	*
	68	* @param element
	69	* the extension point element to be described.
	70	* @throws CoreException
	71	* when <code>enabledWhen</code> expression is not valid.
	72	*/
	73	public CodeMiningProviderDescriptor(IConfigurationElement element) throws CoreException {
	74	Assert.isLegal(element != null);
	75	fConfiguration = element;
	76	fEnabledWhen = createEnabledWhen(fConfiguration, getId());
	77	}
	78
	79	/**
	80	* Returns the expression {@link Expression} declared in the
	81	* <code>enabledWhen</code> element.
	82	*
	83	* @param configElement
	84	* the configuration element
	85	* @param id
	86	* the id of the codemining provider.
	87	* @return the expression {@link Expression} declared in the enabledWhen
	88	* element.
	89	* @throws CoreException
	90	* when enabledWhen expression is not valid.
	91	*/
	92	private static Expression createEnabledWhen(IConfigurationElement configElement, String id) throws CoreException {
	93	final IConfigurationElement[] children = configElement.getChildren(ENABLED_WHEN_ATTR);
	94	if (children.length > 0) {
	95	IConfigurationElement[] subChildren = children[0].getChildren();
	96	if (subChildren.length != 1) {
	97	throw new CoreException(new Status(IStatus.ERROR, TextEditorPlugin.PLUGIN_ID,
	98	"One <enabledWhen> element is accepted. Disabling " + id)); //$NON-NLS-1$
	99	}
	100	final ElementHandler elementHandler = ElementHandler.getDefault();
	101	final ExpressionConverter converter = ExpressionConverter.getDefault();
	102	return elementHandler.create(converter, subChildren[0]);
	103
	104	}
	105	throw new CoreException(new Status(IStatus.ERROR, TextEditorPlugin.PLUGIN_ID,
	106	"<enabledWhen> element is required. Disabling " + id)); //$NON-NLS-1$
	107	}
	108
	109	/**
	110	* Reads (if needed) and returns the label of this extension.
	111	*
	112	* @return the label for this extension.
	113	*/
	114	public String getLabel() {
	115	if (fLabel == null) {
	116	fLabel = fConfiguration.getAttribute(LABEL_ATTRIBUTE);
	117	Assert.isNotNull(fLabel);
	118	}
	119	return fLabel;
	120	}
	121
	122	/**
	123	* Reads (if needed) and returns the id of this extension.
	124	*
	125	* @return the id for this extension.
	126	*/
	127	public String getId() {
	128	if (fId == null) {
	129	fId = fConfiguration.getAttribute(ID_ATTRIBUTE);
	130	Assert.isNotNull(fId);
	131	}
	132	return fId;
	133	}
	134
	135	/**
	136	* Creates a codemining provider as described in the extension's xml. and null
	137	* otherwise.
	138	*
	139	* @param editor
	140	* the text editor
	141	*
	142	* @return the created codemining provider and null otherwise.
	143	*/
	144	protected ICodeMiningProvider createCodeMiningProvider(ITextEditor editor) {
	145	try {
	146	Object extension = fConfiguration.createExecutableExtension(CLASS_ATTRIBUTE);
	147	if (extension instanceof ICodeMiningProvider) {
	148	if (extension instanceof AbstractCodeMiningProvider) {
	149	((AbstractCodeMiningProvider) extension).setContext(editor);
	150	}
	151	return (ICodeMiningProvider) extension;
	152	} else {
	153	String message = "Invalid extension to codeMiningProviders. Must extends ICodeMiningProvider: " //$NON-NLS-1$
	154	+ getId();
	155	TextEditorPlugin.getDefault().getLog()
	156	.log(new Status(IStatus.ERROR, TextEditorPlugin.PLUGIN_ID, message));
	157	return null;
	158	}
	159	} catch (CoreException e) {
	160	TextEditorPlugin.getDefault().getLog().log(new Status(IStatus.ERROR, TextEditorPlugin.PLUGIN_ID,
	161	"Error while creating codeMiningProvider: " + getId(), e)); //$NON-NLS-1$
	162	return null;
	163	}
	164	}
	165
	166	/**
	167	* Returns true if the given viewer, editor matches the enabledWhen expression
	168	* and false otherwise.
	169	*
	170	* @param viewer
	171	* the viewer
	172	* @param editor
	173	* the editor
	174	* @return true if the given viewer, editor matches the enabledWhen expression
	175	* and false otherwise.
	176	*/
	177	public boolean matches(ISourceViewer viewer, ITextEditor editor) {
	178	EvaluationContext context = new EvaluationContext(null, editor);
	179	context.setAllowPluginActivation(true);
	180	context.addVariable("viewer", viewer); //$NON-NLS-1$
	181	context.addVariable("editor", editor); //$NON-NLS-1$
	182	context.addVariable("editorInput", editor.getEditorInput()); //$NON-NLS-1$
	183	try {
	184	return fEnabledWhen.evaluate(context) == EvaluationResult.TRUE;
	185	} catch (CoreException e) {
	186	TextEditorPlugin.getDefault().getLog().log(
	187	new Status(IStatus.ERROR, TextEditorPlugin.PLUGIN_ID, "Error while 'enabledWhen' evaluation", e)); //$NON-NLS-1$
	188	return false;
	189	}
	190	}
	191
	192	}

+117

-0

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/internal/texteditor/codemining/CodeMiningProviderRegistry.java less more

	0	/**
	1	* Copyright (c) 2017 Angelo ZERR.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide extension point for CodeMining - Bug 528419
	9	*/
	10	package org.eclipse.ui.internal.texteditor.codemining;
	11
	12	import java.util.ArrayList;
	13	import java.util.List;
	14
	15	import org.eclipse.core.runtime.CoreException;
	16	import org.eclipse.core.runtime.IConfigurationElement;
	17	import org.eclipse.core.runtime.IStatus;
	18	import org.eclipse.core.runtime.Platform;
	19	import org.eclipse.core.runtime.Status;
	20
	21	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
	22	import org.eclipse.jface.text.source.ISourceViewer;
	23
	24	import org.eclipse.ui.internal.texteditor.TextEditorPlugin;
	25
	26	import org.eclipse.ui.texteditor.ITextEditor;
	27
	28	/**
	29	* A codemining providers registry used to access the
	30	* {@link CodeMiningProviderDescriptor}s that describe the codemining provider
	31	* extensions.
	32	*
	33	* @see CodeMiningProviderDescriptor
	34	* @since 3.10
	35	*/
	36	public class CodeMiningProviderRegistry {
	37
	38	/**
	39	* Extension id of spelling engine extension point. (value
	40	* <code>"codeMiningProviders"</code>).
	41	*/
	42	public static final String CODEMINING_PROVIDERS_EXTENSION_POINT = "codeMiningProviders"; //$NON-NLS-1$
	43
	44	/** All descriptors */
	45	private CodeMiningProviderDescriptor[] fDescriptors;
	46
	47	/** <code>true</code> iff the extensions have been loaded at least once */
	48	private boolean fLoaded = false;
	49
	50	/**
	51	* Returns all descriptors.
	52	*
	53	* @return all descriptors
	54	*/
	55	private CodeMiningProviderDescriptor[] getDescriptors() {
	56	ensureExtensionsLoaded();
	57	return fDescriptors;
	58	}
	59
	60	/**
	61	* Reads all extensions.
	62	* <p>
	63	* This method can be called more than once in order to reload from a changed
	64	* extension registry.
	65	* </p>
	66	*/
	67	public synchronized void reloadExtensions() {
	68	List<CodeMiningProviderDescriptor> descriptors = new ArrayList<>();
	69	IConfigurationElement[] elements = Platform.getExtensionRegistry()
	70	.getConfigurationElementsFor(TextEditorPlugin.PLUGIN_ID, CODEMINING_PROVIDERS_EXTENSION_POINT);
	71	for (int i = 0; i < elements.length; i++) {
	72	IConfigurationElement element = elements[i];
	73	try {
	74	CodeMiningProviderDescriptor descriptor = new CodeMiningProviderDescriptor(element);
	75	descriptors.add(descriptor);
	76	} catch (CoreException e) {
	77	TextEditorPlugin.getDefault().getLog()
	78	.log(new Status(IStatus.ERROR, element.getNamespaceIdentifier(), e.getMessage()));
	79	}
	80	}
	81	fDescriptors = descriptors.toArray(new CodeMiningProviderDescriptor[descriptors.size()]);
	82	fLoaded = true;
	83	}
	84
	85	/**
	86	* Ensures the extensions have been loaded at least once.
	87	*/
	88	private void ensureExtensionsLoaded() {
	89	if (!fLoaded)
	90	reloadExtensions();
	91	}
	92
	93	/**
	94	* Returns the codemining providers for the given viewer and editor and null
	95	* otherwise.
	96	*
	97	* @param viewer
	98	* the viewer
	99	* @param editor
	100	* the editor
	101	* @return the codemining providers for the given viewer and editor and null
	102	* otherwise.
	103	*/
	104	public ICodeMiningProvider[] getProviders(ISourceViewer viewer, ITextEditor editor) {
	105	List<ICodeMiningProvider> providers = new ArrayList<>();
	106	for (CodeMiningProviderDescriptor descriptor : getDescriptors()) {
	107	if (descriptor.matches(viewer, editor)) {
	108	ICodeMiningProvider provider = descriptor.createCodeMiningProvider(editor);
	109	if (provider != null) {
	110	providers.add(provider);
	111	}
	112	}
	113	}
	114	return providers.size() > 0 ? providers.toArray(new ICodeMiningProvider[providers.size()]) : null;
	115	}
	116	}

+1

-1

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/internal/texteditor/rulers/StringSetSerializer.java less more

23	23
24	24	public static String serialize(Set<String> strings) {
25	25	Assert.isLegal(strings != null);
26		StringBuffer buf= new StringBuffer(strings.size() * 20);
	26	StringBuilder buf= new StringBuilder(strings.size() * 20);
27	27	for (Iterator<String> it= strings.iterator(); it.hasNext();) {
28	28	buf.append(it.next());
29	29	if (it.hasNext())

+74

-23

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/AbstractTextEditor.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2016 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

16	16	* Holger Voormann - Word Wrap - https://bugs.eclipse.org/bugs/show_bug.cgi?id=35779
17	17	* Florian Weßling <flo@cdhq.de> - Word Wrap - https://bugs.eclipse.org/bugs/show_bug.cgi?id=35779
18	18	* Andrey Loskutov <loskutov@gmx.de> - Word Wrap - https://bugs.eclipse.org/bugs/show_bug.cgi?id=35779
	19	* Angelo Zerr <angelo.zerr@gmail.com> - [CodeMining] Provide extension point for CodeMining - Bug 528419
19	20	*******************************************************************************/
20	21	package org.eclipse.ui.texteditor;
21	22

149	150	import org.eclipse.jface.text.TextEvent;
150	151	import org.eclipse.jface.text.TextSelection;
151	152	import org.eclipse.jface.text.TextUtilities;
	153	import org.eclipse.jface.text.codemining.ICodeMiningProvider;
152	154	import org.eclipse.jface.text.hyperlink.HyperlinkManager;
153	155	import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;
154	156	import org.eclipse.jface.text.information.IInformationProvider;

164	166	import org.eclipse.jface.text.source.ISourceViewer;
165	167	import org.eclipse.jface.text.source.ISourceViewerExtension3;
166	168	import org.eclipse.jface.text.source.ISourceViewerExtension4;
	169	import org.eclipse.jface.text.source.ISourceViewerExtension5;
167	170	import org.eclipse.jface.text.source.IVerticalRuler;
168	171	import org.eclipse.jface.text.source.IVerticalRulerColumn;
169	172	import org.eclipse.jface.text.source.IVerticalRulerExtension;

192	195	import org.eclipse.ui.IWorkbenchActionConstants;
193	196	import org.eclipse.ui.IWorkbenchCommandConstants;
194	197	import org.eclipse.ui.IWorkbenchPart;
	198	import org.eclipse.ui.IWorkbenchPartSite;
195	199	import org.eclipse.ui.IWorkbenchWindow;
196	200	import org.eclipse.ui.PartInitException;
197	201	import org.eclipse.ui.PlatformUI;

201	205	import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;
202	206	import org.eclipse.ui.actions.CommandNotMappedException;
203	207	import org.eclipse.ui.actions.ContributedAction;
	208	import org.eclipse.ui.commands.ICommandImageService;
204	209	import org.eclipse.ui.dialogs.PropertyDialogAction;
205	210	import org.eclipse.ui.dnd.IDragAndDropService;
206	211	import org.eclipse.ui.internal.texteditor.EditPosition;

618	623	IDocument document= getDocumentProvider().getDocument(input);
619	624
620	625	if (fLocalLastEditPosition != null) {
621		document.removePosition(fLocalLastEditPosition);
	626	if (document != null) {
	627	document.removePosition(fLocalLastEditPosition);
	628	}
622	629	fLocalLastEditPosition= null;
623	630	}
624	631
625	632	if (sel instanceof ITextSelection && !sel.isEmpty()) {
626	633	ITextSelection s= (ITextSelection) sel;
627	634	fLocalLastEditPosition= new Position(s.getOffset(), s.getLength());
628		try {
629		document.addPosition(fLocalLastEditPosition);
630		} catch (BadLocationException ex) {
631		fLocalLastEditPosition= null;
	635	if (document != null) {
	636	try {
	637	document.addPosition(fLocalLastEditPosition);
	638	} catch (BadLocationException ex) {
	639	fLocalLastEditPosition = null;
	640	}
632	641	}
633	642	}
634	643

1890	1899	StyledText styledText= textViewer.getTextWidget();
1891	1900	IDocument document= textViewer.getDocument();
1892	1901
1893		if (document == null)
	1902	int widgetOffset = styledText.getOffsetAtPoint(new Point(x, y));
	1903	if (document == null \|\| widgetOffset == -1) {
1894	1904	return -1;
	1905	}
1895	1906
1896	1907	try {
1897		int widgetOffset= styledText.getOffsetAtLocation(new Point(x, y));
1898	1908	Point p= styledText.getLocationAtOffset(widgetOffset);
1899		if (p.x > x)
	1909	if (p.x > x) {
1900	1910	widgetOffset--;
	1911	}
1901	1912
1902	1913	if (textViewer instanceof ITextViewerExtension5) {
1903	1914	ITextViewerExtension5 extension= (ITextViewerExtension5) textViewer;

3525	3536	if (isBlockSelectionModeEnabled())
3526	3537	return false;
3527	3538
3528		int offset= st.getOffsetAtLocation(point);
	3539	int offset = st.getOffsetAtPoint(point);
3529	3540	Point p= st.getLocationAtOffset(offset);
3530	3541	if (p.x > point.x)
3531	3542	offset--;

4020	4031	EnrichMode mode= store != null ? convertEnrichModePreference(store.getInt(PREFERENCE_HOVER_ENRICH_MODE)) : EnrichMode.AFTER_DELAY;
4021	4032	((ITextViewerExtension8)fSourceViewer).setHoverEnrichMode(mode);
4022	4033	}
	4034
	4035	if (fSourceViewer instanceof ISourceViewerExtension5)
	4036	installCodeMiningProviders();
	4037	}
	4038
	4039	/**
	4040	* Install codemining providers.
	4041	*
	4042	* @since 3.11
	4043	*/
	4044	protected void installCodeMiningProviders() {
	4045	ICodeMiningProvider[] providers = TextEditorPlugin.getDefault().getCodeMiningProviderRegistry()
	4046	.getProviders(this.getSourceViewer(), this);
	4047	((ISourceViewerExtension5) fSourceViewer).setCodeMiningProviders(providers);
4023	4048	}
4024	4049
4025	4050	/**

5322	5347	for (int i= 0; i < elements.length; i++) {
5323	5348	IConfigurationElement element= elements[i];
5324	5349	if (TAG_CONTRIBUTION_TYPE.equals(element.getName())) {
5325		if (!getSite().getId().equals(element.getAttribute("targetID"))) //$NON-NLS-1$
	5350	IWorkbenchPartSite site = getSite();
	5351	if (site == null) {
	5352	return null;
	5353	}
	5354	if (!site.getId().equals(element.getAttribute("targetID"))) //$NON-NLS-1$
5326	5355	continue;
5327	5356
5328	5357	IConfigurationElement[] children= element.getChildren("action"); //$NON-NLS-1$

5663	5692	action= new TextOperationAction(EditorMessages.getBundleForConstructedKeys(), "Editor.Cut.", this, ITextOperationTarget.CUT); //$NON-NLS-1$
5664	5693	action.setHelpContextId(IAbstractTextEditorHelpContextIds.CUT_ACTION);
5665	5694	action.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_CUT);
	5695	updateImages(action, IWorkbenchCommandConstants.EDIT_CUT);
5666	5696	setAction(ITextEditorActionConstants.CUT, action);
5667	5697
5668	5698	setAction(IWorkbenchCommandConstants.EDIT_COPY, null);
5669	5699	action= new TextOperationAction(EditorMessages.getBundleForConstructedKeys(), "Editor.Copy.", this, ITextOperationTarget.COPY, true); //$NON-NLS-1$
5670	5700	action.setHelpContextId(IAbstractTextEditorHelpContextIds.COPY_ACTION);
5671	5701	action.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_COPY);
	5702	updateImages(action, IWorkbenchCommandConstants.EDIT_COPY);
5672	5703	setAction(ITextEditorActionConstants.COPY, action);
5673	5704
5674	5705	setAction(IWorkbenchCommandConstants.EDIT_PASTE, null);
5675	5706	action= new TextOperationAction(EditorMessages.getBundleForConstructedKeys(), "Editor.Paste.", this, ITextOperationTarget.PASTE); //$NON-NLS-1$
5676	5707	action.setHelpContextId(IAbstractTextEditorHelpContextIds.PASTE_ACTION);
5677	5708	action.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_PASTE);
	5709	updateImages(action, IWorkbenchCommandConstants.EDIT_PASTE);
5678	5710	setAction(ITextEditorActionConstants.PASTE, action);
5679	5711
5680	5712	action= new TextOperationAction(EditorMessages.getBundleForConstructedKeys(), "Editor.Delete.", this, ITextOperationTarget.DELETE); //$NON-NLS-1$
5681	5713	action.setHelpContextId(IAbstractTextEditorHelpContextIds.DELETE_ACTION);
5682	5714	action.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_DELETE);
	5715	updateImages(action, IWorkbenchCommandConstants.EDIT_DELETE);
5683	5716	setAction(ITextEditorActionConstants.DELETE, action);
5684	5717
5685	5718	action= new DeleteLineAction(EditorMessages.getBundleForConstructedKeys(), "Editor.DeleteLine.", this, DeleteLineAction.WHOLE, false); //$NON-NLS-1$

5758	5791	action= new TextOperationAction(EditorMessages.getBundleForConstructedKeys(), "Editor.Print.", this, ITextOperationTarget.PRINT, true); //$NON-NLS-1$
5759	5792	action.setHelpContextId(IAbstractTextEditorHelpContextIds.PRINT_ACTION);
5760	5793	action.setActionDefinitionId(IWorkbenchCommandConstants.FILE_PRINT);
	5794	updateImages(action, IWorkbenchCommandConstants.FILE_PRINT);
5761	5795	setAction(ITextEditorActionConstants.PRINT, action);
5762	5796
5763	5797	action= new FindReplaceAction(EditorMessages.getBundleForConstructedKeys(), "Editor.FindReplace.", this); //$NON-NLS-1$
5764	5798	action.setHelpContextId(IAbstractTextEditorHelpContextIds.FIND_ACTION);
5765	5799	action.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_FIND_AND_REPLACE);
	5800	updateImages(action, IWorkbenchCommandConstants.EDIT_FIND_AND_REPLACE);
5766	5801	setAction(ITextEditorActionConstants.FIND, action);
5767	5802
5768	5803	action= new FindNextAction(EditorMessages.getBundleForConstructedKeys(), "Editor.FindNext.", this, true); //$NON-NLS-1$

5791	5826	action= new RevertToSavedAction(EditorMessages.getBundleForConstructedKeys(), "Editor.Revert.", this); //$NON-NLS-1$
5792	5827	action.setHelpContextId(IAbstractTextEditorHelpContextIds.REVERT_TO_SAVED_ACTION);
5793	5828	action.setActionDefinitionId(IWorkbenchCommandConstants.FILE_REVERT);
	5829	updateImages(action, IWorkbenchCommandConstants.FILE_REVERT);
5794	5830	setAction(ITextEditorActionConstants.REVERT_TO_SAVED, action);
5795	5831
5796	5832	action= new GotoLineAction(EditorMessages.getBundleForConstructedKeys(), "Editor.GotoLine.", this); //$NON-NLS-1$

5948	5984	}
5949	5985	});
5950	5986	openProperties.setActionDefinitionId(IWorkbenchCommandConstants.FILE_PROPERTIES);
	5987	updateImages(openProperties, IWorkbenchCommandConstants.FILE_PROPERTIES);
5951	5988	setAction(ITextEditorActionConstants.PROPERTIES, openProperties);
5952	5989
5953	5990	markAsContentDependentAction(ITextEditorActionConstants.UNDO, true);

5994	6031	setActionActivationCode(ITextEditorActionConstants.SHIFT_LEFT, '\t', -1, SWT.SHIFT);
5995	6032	}
5996	6033
	6034	private void updateImages(IAction action, String commandId) {
	6035	if (action.getImageDescriptor() != null) {
	6036	return;
	6037	}
	6038	ICommandImageService imgService = getSite().getService(ICommandImageService.class);
	6039	if (imgService == null) {
	6040	return;
	6041	}
	6042	action.setImageDescriptor(imgService.getImageDescriptor(commandId));
	6043	action.setDisabledImageDescriptor(imgService.getImageDescriptor(commandId, ICommandImageService.TYPE_DISABLED));
	6044	action.setHoverImageDescriptor(imgService.getImageDescriptor(commandId, ICommandImageService.TYPE_HOVER));
	6045	}
	6046
5997	6047	/**
5998	6048	* Convenience method to add the action installed under the given action id to the given menu.
5999	6049	* @param menu the menu to add the action to

6186	6236
6187	6237	@Override
6188	6238	public void setFocus() {
6189		if (fSourceViewer != null && fSourceViewer.getTextWidget() != null)
6190		fSourceViewer.getTextWidget().setFocus();
	6239	if (fSourceViewer != null) {
	6240	StyledText widget= fSourceViewer.getTextWidget();
	6241	if (widget != null && !widget.isDisposed()) {
	6242	widget.setFocus();
	6243	}
	6244	}
6191	6245	}
6192	6246
6193	6247	@Override

6536	6590
6537	6591	Caret caret= new Caret(styledText, SWT.NULL);
6538	6592	Image image= createRawInsertModeCaretImage(styledText);
6539		if (image != null)
6540		caret.setImage(image);
6541		else {
6542		// XXX: Filed request to get a caret with auto-height: https://bugs.eclipse.org/bugs/show_bug.cgi?id=118612
6543		caret.setSize(getCaretWidthPreference(), styledText.getLineHeight());
6544		}
6545
	6593	caret.setImage(image);
6546	6594	caret.setFont(styledText.getFont());
6547	6595
6548	6596	return caret;

6556	6604	}
6557	6605
6558	6606	private void updateCaret() {
6559
6560		if (fSourceViewer == null)
	6607	if (fSourceViewer == null \|\| fSourceViewer.getTextWidget() == null) {
6561	6608	return;
	6609	}
6562	6610
6563	6611	StyledText styledText= fSourceViewer.getTextWidget();
6564	6612

6910	6958	boolean currentAnnotation= false;
6911	6959
6912	6960	IDocument document= getDocumentProvider().getDocument(getEditorInput());
6913		int endOfDocument= document.getLength();
	6961	int endOfDocument = 0;
	6962	if (document != null) {
	6963	endOfDocument = document.getLength();
	6964	}
6914	6965	int distance= Integer.MAX_VALUE;
6915	6966
6916	6967	IAnnotationModel model= getDocumentProvider().getAnnotationModel(getEditorInput());

+16

-4

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/AbstractTextZoomHandler.java less more

21	21	import org.eclipse.core.commands.AbstractHandler;
22	22	import org.eclipse.core.commands.ExecutionEvent;
23	23	import org.eclipse.core.commands.ExecutionException;
	24	import org.eclipse.core.expressions.IEvaluationContext;
24	25
25	26	import org.eclipse.core.runtime.IConfigurationElement;
26	27	import org.eclipse.core.runtime.Platform;

30	31	import org.eclipse.jface.resource.FontRegistry;
31	32	import org.eclipse.jface.resource.JFaceResources;
32	33
33		import org.eclipse.ui.IWorkbenchPart;
	34	import org.eclipse.ui.IEditorPart;
	35	import org.eclipse.ui.ISources;
34	36	import org.eclipse.ui.handlers.HandlerUtil;
35	37	import org.eclipse.ui.part.AbstractMultiEditor;
36	38	import org.eclipse.ui.part.MultiPageEditorPart;

92	94	}
93	95
94	96	private AbstractTextEditor getActiveTextEditor(ExecutionEvent event) {
95		IWorkbenchPart part= HandlerUtil.getActiveEditor(event);
	97	return getActiveTextEditor(HandlerUtil.getActiveEditor(event));
	98	}
	99
	100	private AbstractTextEditor getActiveTextEditor(IEditorPart part) {
96	101	if (part instanceof AbstractTextEditor) {
97	102	return (AbstractTextEditor)part;
98	103	} else if ((part instanceof AbstractMultiEditor) && ((AbstractMultiEditor)part).getActiveEditor() instanceof AbstractTextEditor) {

104	109	}
105	110
106	111	@Override
107		public boolean isEnabled() {
108		return true;
	112	public void setEnabled(Object evaluationContext) {
	113	boolean enabled = false;
	114	if (evaluationContext instanceof IEvaluationContext) {
	115	Object activeEditor = ((IEvaluationContext) evaluationContext).getVariable(ISources.ACTIVE_EDITOR_NAME);
	116	if (activeEditor instanceof IEditorPart) {
	117	enabled = getActiveTextEditor((IEditorPart) activeEditor) != null;
	118	}
	119	}
	120	setBaseEnabled(enabled);
109	121	}
110	122
111	123	/**

+1

-0

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/ConstructedEditorMessages.properties less more

148	148	Editor.GotoLine.tooltip=Go to Line
149	149	Editor.GotoLine.image=
150	150	Editor.GotoLine.description=Go to Line
	151	Editor.GotoLine.button=&Go to Line
151	152
152	153	Editor.GotoLine.dialog.title=Go to Line
153	154	Editor.GotoLine.dialog.message=Enter line number (1..{0}):

+35

-34

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/DefaultRangeIndicator.java less more

26	26	import org.eclipse.swt.widgets.Control;
27	27	import org.eclipse.swt.widgets.Display;
28	28
	29	import org.eclipse.jface.resource.JFaceResources;
	30
29	31	import org.eclipse.jface.text.source.Annotation;
30	32	import org.eclipse.jface.text.source.IAnnotationPresentation;
31	33

40	42	*/
41	43	public class DefaultRangeIndicator extends Annotation implements IAnnotationPresentation {
42	44
43		/** The color palette data of this range indicator */
44		private static PaletteData fgPaletteData;
	45	private static final String RANGE_INDICATOR_COLOR= "org.eclipse.ui.editors.rangeIndicatorColor"; //$NON-NLS-1$
45	46	/** The image of this range indicator */
46	47	private Image fImage;
	48	/** The color used to draw the range indicator during the last paint action. */
	49	private Color fLastRangeIndicatorColor;
47	50
48	51	/**
49	52	* Creates a new range indicator.

53	56
54	57	@Override
55	58	public void paint(GC gc, Canvas canvas, Rectangle bounds) {
56
57	59	Point canvasSize= canvas.getSize();
58	60
59	61	int x= 0;

73	75	if (h <= 0)
74	76	return;
75	77
76		Image image = getImage(canvas);
	78	Color currentRangeIndicatorColor= JFaceResources.getColorRegistry().get(RANGE_INDICATOR_COLOR);
	79	Image image= getImage(canvas, currentRangeIndicatorColor);
77	80	gc.drawImage(image, 0, 0, w, h, x, y, w, h);
78	81
79		gc.setBackground(canvas.getDisplay().getSystemColor(SWT.COLOR_LIST_SELECTION));
	82	gc.setBackground(currentRangeIndicatorColor);
80	83	gc.fillRectangle(x, bounds.y, w, b);
81	84	gc.fillRectangle(x, bounds.y + bounds.height - b, w, b);
	85
	86	fLastRangeIndicatorColor= currentRangeIndicatorColor;
82	87	}
83	88
84	89	@Override

90	95	* Returns the image of this range indicator.
91	96	*
92	97	* @param control the control
	98	* @param rangeIndicatorColor the color to be used to paint the range indicator
93	99	* @return an image
94	100	*/
95		private Image getImage(Control control) {
	101	private Image getImage(Control control, Color rangeIndicatorColor) {
96	102	if (fImage == null) {
97		fImage= createImage(control.getDisplay(), control.getSize());
	103	fImage= createImage(control.getDisplay(), control.getSize(), rangeIndicatorColor);
98	104
99		control.addDisposeListener(new DisposeListener() {
100		@Override
101		public void widgetDisposed(DisposeEvent e) {
102		if (fImage != null && !fImage.isDisposed()) {
103		fImage.dispose();
104		fImage= null;
105		}
	105	control.addDisposeListener(new DisposeListener() {
	106	@Override
	107	public void widgetDisposed(DisposeEvent e) {
	108	if (fImage != null && !fImage.isDisposed()) {
	109	fImage.dispose();
	110	fImage = null;
106	111	}
107		});
	112	}
	113	});
108	114	} else {
109	115	Rectangle imageRectangle= fImage.getBounds();
110	116	Point controlSize= control.getSize();
111	117
112		if (imageRectangle.width < controlSize.x \|\| imageRectangle.height < controlSize.y) {
	118	if (imageRectangle.width < controlSize.x \|\| imageRectangle.height < controlSize.y
	119	\|\| !rangeIndicatorColor.equals(fLastRangeIndicatorColor)) {
113	120	fImage.dispose();
114		fImage= createImage(control.getDisplay(), controlSize);
	121	fImage= createImage(control.getDisplay(), controlSize, rangeIndicatorColor);
115	122	}
116	123	}
117	124

124	131	*
125	132	* @param display the display on which to create the image
126	133	* @param size the image size
	134	* @param rangeIndicatorColor the color to be used to paint the range indicator
127	135	* @return a new image
128		*/
129		private static Image createImage(Display display, Point size) {
	136	*/
	137	private static Image createImage(Display display, Point size, Color rangeIndicatorColor) {
130	138
131	139	int width= size.x;
132	140	int height= size.y;
133	141
134		if (fgPaletteData == null)
135		fgPaletteData= createPalette(display);
136	142
137		ImageData imageData= new ImageData(width, height, 1, fgPaletteData);
	143	ImageData imageData= new ImageData(width, height, 1, createPalette(display, rangeIndicatorColor));
138	144
139	145	for (int y= 0; y < height; y++)
140	146	for (int x= 0; x < width; x++)
141	147	imageData.setPixel(x, y, (x + y) % 2);
	148
	149	imageData.transparentPixel= imageData.palette.getPixel(imageData.getRGBs()[1]);
	150
142	151
143	152	return new Image(display, imageData);
144	153	}

147	156	* Creates and returns a new color palette data.
148	157	*
149	158	* @param display the display
	159	* @param rangeIndicatorColor the color to be used to paint the range indicator
150	160	* @return the new color palette data
151	161	*/
152		private static PaletteData createPalette(Display display) {
153		Color c1;
154		Color c2;
155
156		c1= display.getSystemColor(SWT.COLOR_LIST_SELECTION);
157		c2= display.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);
158
159		RGB rgbs[]= new RGB[] {
160		new RGB(c1.getRed(), c1.getGreen(), c1.getBlue()),
161		new RGB(c2.getRed(), c2.getGreen(), c2.getBlue())};
162
163		return new PaletteData(rgbs);
	162	private static PaletteData createPalette(Display display, Color rangeIndicatorColor) {
	163	return new PaletteData(new RGB[] { rangeIndicatorColor.getRGB(),
	164	display.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND).getRGB() });
164	165	}
165	166	}

+2

-2

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/FindReplaceDialog.java less more

455	455	e.doit= false;
456	456	}
457	457	else if (e.detail == SWT.TRAVERSE_MNEMONIC) {
458		Character mnemonic= new Character(Character.toLowerCase(e.character));
	458	Character mnemonic= Character.valueOf(Character.toLowerCase(e.character));
459	459	if (fMnemonicButtonMap.containsKey(mnemonic)) {
460	460	Button button= fMnemonicButtonMap.get(mnemonic);
461	461	if ((fFindField.isFocusControl() \|\| fReplaceField.isFocusControl() \|\| (button.getStyle() & SWT.PUSH) != 0)

1284	1284	private void storeButtonWithMnemonicInMap(Button button) {
1285	1285	char mnemonic= LegacyActionTools.extractMnemonic(button.getText());
1286	1286	if (mnemonic != LegacyActionTools.MNEMONIC_NONE)
1287		fMnemonicButtonMap.put(new Character(Character.toLowerCase(mnemonic)), button);
	1287	fMnemonicButtonMap.put(Character.valueOf(Character.toLowerCase(mnemonic)), button);
1288	1288	}
1289	1289
1290	1290	/**

+11

-5

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/GotoLineAction.java less more

12	12	import java.util.ResourceBundle;
13	13
14	14	import org.eclipse.swt.custom.StyledText;
	15	import org.eclipse.swt.widgets.Button;
	16	import org.eclipse.swt.widgets.Composite;
15	17	import org.eclipse.swt.widgets.Control;
16	18	import org.eclipse.swt.widgets.Shell;
17	19

85	87	*
86	88	* @since 2.0
87	89	*/
88		static class GotoLineDialog extends InputDialog {
89
90		/*
91		* @see InputDialog#InputDialog(org.eclipse.swt.widgets.Shell, java.lang.String, java.lang.String, java.lang.String, org.eclipse.jface.dialogs.IInputValidator)
92		*/
	90	class GotoLineDialog extends InputDialog {
	91
93	92	public GotoLineDialog(Shell parent, String title, String message, String initialValue, IInputValidator validator) {
94	93	super(parent, title, message, initialValue, validator);
95	94	}

102	101	if (section == null)
103	102	section= settings.addNewSection(sectionName);
104	103	return section;
	104	}
	105
	106	@Override
	107	protected void createButtonsForButtonBar(Composite parent) {
	108	super.createButtonsForButtonBar(parent);
	109	Button button = getOkButton();
	110	button.setText(GotoLineAction.this.fBundle.getString(fPrefix + "button")); //$NON-NLS-1$
105	111	}
106	112
107	113	@Override

+4

-4

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/IncrementalFindTarget.java less more

88	88	/** The find replace target to delegate find requests */
89	89	private final IFindReplaceTarget fTarget;
90	90	/** The current find string */
91		private StringBuffer fFindString= new StringBuffer();
	91	private StringBuilder fFindString= new StringBuilder();
92	92	/** The position of the first upper case character, -1 if none */
93	93	private int fCasePosition;
94	94	/**

192	192	text.setSelectionRange(searchResult.selection, searchResult.length);
193	193	text.showSelection();
194	194
195		// relies on the contents of the StringBuffer
	195	// relies on the contents of the StringBuilder
196	196	fFindString.setLength(searchResult.findLength);
197	197	fCurrentIndex= searchResult.index;
198	198	fFound= searchResult.found;

502	502	*/
503	503	private boolean repeatSearch(boolean forward) {
504	504	if (fFindString.length() == 0) {
505		fFindString= new StringBuffer(fPrevFindString);
	505	fFindString= new StringBuilder(fPrevFindString);
506	506	fCasePosition= fPrevCasePosition;
507	507	}
508	508

717	717	* @return the given string with all tab characters replace with a proper status line presentation
718	718	*/
719	719	private String escapeTabs(String string) {
720		StringBuffer buffer= new StringBuffer();
	720	StringBuilder buffer= new StringBuilder();
721	721
722	722	int begin= 0;
723	723	int end= string.indexOf('\t', begin);

+1

-1

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/JoinLinesAction.java less more

148	148	if (startLine == endLine)
149	149	endLine++; // append join with the next line
150	150
151		StringBuffer buffer= new StringBuffer();
	151	StringBuilder buffer= new StringBuilder();
152	152	for (int line= startLine; line <= endLine; line++) {
153	153	buffer.append(trim(document, line, line == startLine));
154	154	if (line != endLine)

+9

-32

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/SourceViewerDecorationSupport.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2012 IBM Corporation and others.
	1	* Copyright (c) 2000, 2017 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

22	22
23	23	import org.eclipse.jface.preference.IPreferenceStore;
24	24	import org.eclipse.jface.preference.PreferenceConverter;
25		import org.eclipse.jface.resource.JFaceResources;
26	25	import org.eclipse.jface.util.IPropertyChangeListener;
27	26	import org.eclipse.jface.util.PropertyChangeEvent;
28	27

40	39	import org.eclipse.jface.text.source.IOverviewRuler;
41	40	import org.eclipse.jface.text.source.ISharedTextColors;
42	41	import org.eclipse.jface.text.source.ISourceViewer;
	42	import org.eclipse.jface.text.source.ISourceViewerExtension5;
43	43	import org.eclipse.jface.text.source.MatchingCharacterPainter;
44	44
45	45

186	186	private static ITextStyleStrategy fgProblemUnderlineStrategy= new AnnotationPainter.UnderlineStrategy(SWT.UNDERLINE_ERROR);
187	187
188	188
189		/*
190		* @see IPropertyChangeListener
191		*/
192		private class FontPropertyChangeListener implements IPropertyChangeListener {
193		@Override
194		public void propertyChange(PropertyChangeEvent event) {
195		if (fMarginPainter != null && fSymbolicFontName != null && fSymbolicFontName.equals(event.getProperty()))
196		fMarginPainter.initialize();
197		}
198		}
199
200
201	189	/** The viewer */
202	190	private ISourceViewer fSourceViewer;
203	191	/** The viewer's overview ruler */

242	230	private IPropertyChangeListener fPropertyChangeListener;
243	231	/** The preference store */
244	232	private IPreferenceStore fPreferenceStore;
245		/** The symbolic font name */
246		private String fSymbolicFontName;
247		/** The font change listener */
248		private FontPropertyChangeListener fFontPropertyChangeListener;
249	233
250	234
251	235	/**

387	371	updateTextDecorations();
388	372	updateOverviewDecorations();
389	373
390		if (fFontPropertyChangeListener != null) {
391		JFaceResources.getFontRegistry().removeListener(fFontPropertyChangeListener);
392		fFontPropertyChangeListener= null;
393		}
394
395	374	fOverviewRuler= null;
396	375
397	376	// Painters got disposed in updateTextDecorations() or by the PaintManager

496	475	/**
497	476	* Sets the symbolic font name that is used for computing the margin width.
498	477	*
499		* @param symbolicFontName the symbolic font name
500		*/
	478	* @param symbolicFontName
	479	* the symbolic font name
	480	* @deprecated As of 4.8, this is no longer used
	481	*/
	482	@Deprecated
501	483	public void setSymbolicFontName(String symbolicFontName) {
502		fSymbolicFontName= symbolicFontName;
503	484	}
504	485
505	486	/**

800	781	fMarginPainter.setMarginRulerColumn(fPreferenceStore.getInt(fMarginPainterColumnKey));
801	782	ITextViewerExtension2 extension= (ITextViewerExtension2) fSourceViewer;
802	783	extension.addPainter(fMarginPainter);
803
804		fFontPropertyChangeListener= new FontPropertyChangeListener();
805		JFaceResources.getFontRegistry().addListener(fFontPropertyChangeListener);
806	784	}
807	785	}
808	786	}

813	791	private void hideMargin() {
814	792	if (fMarginPainter != null) {
815	793	if (fSourceViewer instanceof ITextViewerExtension2) {
816		JFaceResources.getFontRegistry().removeListener(fFontPropertyChangeListener);
817		fFontPropertyChangeListener= null;
818
819	794	ITextViewerExtension2 extension= (ITextViewerExtension2) fSourceViewer;
820	795	extension.removePainter(fMarginPainter);
821	796	fMarginPainter.deactivate(true);

851	826	((ITextViewerExtension4)fSourceViewer).addTextPresentationListener(fAnnotationPainter);
852	827	ITextViewerExtension2 extension= (ITextViewerExtension2) fSourceViewer;
853	828	extension.addPainter(fAnnotationPainter);
	829	if (fSourceViewer instanceof ISourceViewerExtension5)
	830	((ISourceViewerExtension5) fSourceViewer).setCodeMiningAnnotationPainter(fAnnotationPainter);
854	831	}
855	832	fAnnotationPainter.setAnnotationTypeColor(annotationType, getAnnotationTypeColor(annotationType));
856	833	Object decorationType= getAnnotationDecorationType(annotationType);

+1

-1

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/TextViewerDeleteLineTarget.java less more

77	77	/** The clip board. */
78	78	private Clipboard fClipboard;
79	79	/** A string buffer. */
80		private final StringBuffer fBuffer= new StringBuffer();
	80	private final StringBuilder fBuffer= new StringBuilder();
81	81	/** The delete flag indicates if a deletion is in progress. */
82	82	private boolean fDeleting;
83	83

+7

-6

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/templates/AbstractTemplatesPage.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2007, 2012 Dakshinamurthy Karra, IBM Corporation and others.
	1	* Copyright (c) 2007, 2018 Dakshinamurthy Karra, IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

1197	1197	* Set the selected templates
1198	1198	*/
1199	1199	private void setSelectedTemplates() {
1200		IStructuredSelection selection= (IStructuredSelection) fTreeViewer.getSelection();
	1200	IStructuredSelection selection = fTreeViewer.getStructuredSelection();
1201	1201
1202	1202	Iterator<?> it= selection.iterator();
1203	1203	TemplatePersistenceData[] data= new TemplatePersistenceData[selection.size()];

1244	1244	* registry if no templates are selected
1245	1245	*/
1246	1246	private String getContextTypeId() {
1247		IStructuredSelection selection= (IStructuredSelection) fTreeViewer.getSelection();
	1247	IStructuredSelection selection = fTreeViewer.getStructuredSelection();
1248	1248	Object item;
1249	1249
1250	1250	if (selection.size() == 0)

1570	1570	int widgetCaret= fViewer.getTextWidget().getCaretOffset();
1571	1571	if (fViewer instanceof ITextViewerExtension5) {
1572	1572	ITextViewerExtension5 ext= (ITextViewerExtension5) fViewer;
1573		try {
1574		return ext.widgetOffset2ModelOffset(textWidget.getOffsetAtLocation(point));
1575		} catch (IllegalArgumentException e) {
	1573	int widgetOffset = textWidget.getOffsetAtPoint(point);
	1574	int offset = widgetOffset != -1 ? ext.widgetOffset2ModelOffset(textWidget.getOffsetAtPoint(point)) : -1;
	1575	if (offset == -1) {
1576	1576	int docLineIndex= ext.widgetLine2ModelLine(textWidget.getLineIndex(point.y));
1577	1577	String lineDelimiter= document.getLineDelimiter(docLineIndex);
1578	1578	int delimLength= lineDelimiter == null ? 0 : lineDelimiter.length();
1579	1579	return document.getLineOffset(docLineIndex) + document.getLineLength(docLineIndex)
1580	1580	- delimLength;
1581	1581	}
	1582	return offset;
1582	1583	}
1583	1584	IRegion visible= fViewer.getVisibleRegion();
1584	1585	return widgetCaret + visible.getOffset();

+9

-26

org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/texteditor/templates/TemplatePreferencePage.java less more

0	0	/*******************************************************************************
1		* Copyright (c) 2000, 2015 IBM Corporation and others.
	1	* Copyright (c) 2000, 2018 IBM Corporation and others.
2	2	* All rights reserved. This program and the accompanying materials
3	3	* are made available under the terms of the Eclipse Public License v1.0
4	4	* which accompanies this distribution, and is available at

1181	1181	* Updates the pattern viewer.
1182	1182	*/
1183	1183	protected void updateViewerInput() {
1184		IStructuredSelection selection= (IStructuredSelection) fTableViewer.getSelection();
	1184	IStructuredSelection selection = fTableViewer.getStructuredSelection();
1185	1185
1186	1186	if (selection.size() == 1) {
1187	1187	TemplatePersistenceData data= (TemplatePersistenceData) selection.getFirstElement();

1196	1196	* Updates the buttons.
1197	1197	*/
1198	1198	protected void updateButtons() {
1199		IStructuredSelection selection= (IStructuredSelection) fTableViewer.getSelection();
	1199	IStructuredSelection selection = fTableViewer.getStructuredSelection();
1200	1200	int selectionCount= selection.size();
1201	1201	int itemCount= fTableViewer.getTable().getItemCount();
1202	1202	boolean canRestore= fTemplateStore.getTemplateData(true).length != fTemplateStore.getTemplateData(false).length;

1267	1267	}
1268	1268
1269	1269	private void edit() {
1270		IStructuredSelection selection= (IStructuredSelection) fTableViewer.getSelection();
	1270	IStructuredSelection selection = fTableViewer.getStructuredSelection();
1271	1271
1272	1272	Object[] objects= selection.toArray();
1273	1273	if ((objects == null) \|\| (objects.length != 1))

1314	1314	TemplateReaderWriter reader= new TemplateReaderWriter();
1315	1315	File file= new File(path);
1316	1316	if (file.exists()) {
1317		InputStream input= new BufferedInputStream(new FileInputStream(file));
1318		try {
	1317	try (InputStream input = new BufferedInputStream(new FileInputStream(file))) {
1319	1318	TemplatePersistenceData[] datas= reader.read(input, null);
1320	1319	for (int i= 0; i < datas.length; i++) {
1321	1320	TemplatePersistenceData data= datas[i];

1330	1329	}
1331	1330	}
1332	1331	}
1333		} finally {
1334		try {
1335		input.close();
1336		} catch (IOException x) {
1337		// ignore
1338		}
1339	1332	}
1340	1333	}
1341	1334

1353	1346	}
1354	1347
1355	1348	private void export() {
1356		IStructuredSelection selection= (IStructuredSelection) fTableViewer.getSelection();
	1349	IStructuredSelection selection = fTableViewer.getStructuredSelection();
1357	1350	Object[] templates= selection.toArray();
1358	1351
1359	1352	TemplatePersistenceData[] datas= new TemplatePersistenceData[templates.length];

1390	1383	}
1391	1384
1392	1385	if (!file.exists() \|\| confirmOverwrite(file)) {
1393		OutputStream output= null;
1394		try {
1395		output= new BufferedOutputStream(new FileOutputStream(file));
	1386	try (OutputStream output = new BufferedOutputStream(new FileOutputStream(file))) {
1396	1387	TemplateReaderWriter writer= new TemplateReaderWriter();
1397	1388	writer.save(templates, output);
1398	1389	} catch (IOException e) {
1399	1390	openWriteErrorDialog(e);
1400		} finally {
1401		if (output != null) {
1402		try {
1403		output.close();
1404		} catch (IOException e) {
1405		// ignore
1406		}
1407		}
1408	1391	}
1409	1392	}
1410	1393	}

1416	1399	}
1417	1400
1418	1401	private void remove() {
1419		IStructuredSelection selection= (IStructuredSelection) fTableViewer.getSelection();
	1402	IStructuredSelection selection = fTableViewer.getStructuredSelection();
1420	1403
1421	1404	Iterator<?> elements= selection.iterator();
1422	1405	while (elements.hasNext()) {

1441	1424	}
1442	1425
1443	1426	private void revert() {
1444		IStructuredSelection selection= (IStructuredSelection) fTableViewer.getSelection();
	1427	IStructuredSelection selection = fTableViewer.getStructuredSelection();
1445	1428
1446	1429	Iterator<?> elements= selection.iterator();
1447	1430	while (elements.hasNext()) {

+4

-2

org.eclipse.ui.workbench.texteditor.tests/META-INF/MANIFEST.MF less more

1	1	Bundle-ManifestVersion: 2
2	2	Bundle-Name: %Plugin.name
3	3	Bundle-SymbolicName: org.eclipse.ui.workbench.texteditor.tests
4		Bundle-Version: 3.11.100.qualifier
	4	Bundle-Version: 3.12.0.qualifier
5	5	Bundle-Vendor: %Plugin.providerName
6	6	Bundle-Localization: plugin
7	7	Export-Package:

14	14	org.eclipse.ui.workbench.texteditor;bundle-version="[3.5.0,4.0.0)",
15	15	org.eclipse.ui;bundle-version="[3.5.0,4.0.0)",
16	16	org.junit;bundle-version="4.12.0",
17		org.eclipse.text.tests;bundle-version="[3.5.0,4.0.0)"
	17	org.eclipse.text.tests;bundle-version="[3.5.0,4.0.0)",
	18	org.eclipse.core.expressions;bundle-version="[3.5.0,4.0.0)"
18	19	Bundle-RequiredExecutionEnvironment: JavaSE-1.8
19	20	Eclipse-BundleShape: dir
	21	Automatic-Module-Name: org.eclipse.ui.workbench.texteditor.tests

+2

-2

org.eclipse.ui.workbench.texteditor.tests/pom.xml less more

13	13	<parent>
14	14	<artifactId>tests-pom</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	<relativePath>../tests-pom/</relativePath>
18	18	</parent>
19	19	<groupId>org.eclipse.ui</groupId>
20	20	<artifactId>org.eclipse.ui.workbench.texteditor.tests</artifactId>
21		<version>3.11.100-SNAPSHOT</version>
	21	<version>3.12.0-SNAPSHOT</version>
22	22	<packaging>eclipse-test-plugin</packaging>
23	23	<properties>
24	24	<testSuite>${project.artifactId}</testSuite>

+231

-0

org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/AbstractTextZoomHandlerTest.java less more

	0	/*******************************************************************************
	1	* Copyright (c) 2017 SAP SE and others.
	2	* All rights reserved. This program and the accompanying materials
	3	* are made available under the terms of the Eclipse Public License v1.0
	4	* which accompanies this distribution, and is available at
	5	* http://www.eclipse.org/legal/epl-v10.html
	6	*
	7	* Contributors:
	8	* SAP SE - initial API and implementation
	9	*******************************************************************************/
	10	package org.eclipse.ui.workbench.texteditor.tests;
	11
	12	import static org.junit.Assert.assertEquals;
	13
	14	import org.junit.Test;
	15
	16	import org.eclipse.swt.widgets.Composite;
	17
	18	import org.eclipse.core.expressions.EvaluationContext;
	19
	20	import org.eclipse.core.runtime.IProgressMonitor;
	21
	22	import org.eclipse.ui.IEditorInput;
	23	import org.eclipse.ui.IEditorPart;
	24	import org.eclipse.ui.IEditorReference;
	25	import org.eclipse.ui.IEditorSite;
	26	import org.eclipse.ui.ISources;
	27	import org.eclipse.ui.PartInitException;
	28	import org.eclipse.ui.part.AbstractMultiEditor;
	29	import org.eclipse.ui.part.EditorPart;
	30	import org.eclipse.ui.part.MultiPageEditorPart;
	31
	32	import org.eclipse.ui.texteditor.AbstractTextEditor;
	33	import org.eclipse.ui.texteditor.TextZoomInHandler;
	34
	35	public class AbstractTextZoomHandlerTest {
	36
	37	@Test
	38	public void textZoomIsSupportedForAbstractTextEditor() {
	39	IEditorPart part= new TestAbstractTextEditor();
	40
	41	assertZoomSupported(part, true);
	42	}
	43
	44	@Test
	45	public void textZoomIsNotSupportedForNonTextEditor() {
	46	IEditorPart part= new TestNonTextEditor();
	47
	48	assertZoomSupported(part, false);
	49	}
	50
	51	@Test
	52	public void textZoomIsSupportedForMultiPageEditorPartWithAbstractTextEditorPage() {
	53	EditorPart part= new TestMultiPageEditorPart(new TestAbstractTextEditor());
	54
	55	assertZoomSupported(part, true);
	56	}
	57
	58	@Test
	59	public void textZoomIsNotSupportedForMultiPageEditorPartWithNonTextPage() {
	60	EditorPart part= new TestMultiPageEditorPart(new TestNonTextEditor());
	61
	62	assertZoomSupported(part, false);
	63	}
	64
	65	@Test
	66	public void textZoomIsSupportedForMultiEditorWithTextPage() {
	67	EditorPart part= new TestMultiEditor(new TestAbstractTextEditor());
	68
	69	assertZoomSupported(part, true);
	70	}
	71
	72	@Test
	73	public void textZoomIsNotSupportedForMultiEditorWithNonTextPage() {
	74	EditorPart part= new TestMultiEditor(new TestNonTextEditor());
	75
	76	assertZoomSupported(part, false);
	77	}
	78
	79	@Test
	80	public void textZoomIsSupportedForAdaptableToAbstractTextEditor() {
	81	IEditorPart part= new TestAdaptableToAbstractTestEditor();
	82
	83	assertZoomSupported(part, true);
	84	}
	85
	86	@Test
	87	public void textZoomIsNotSupportedForGenericObject() {
	88	assertZoomSupported(new Object(), false);
	89	}
	90
	91	private void assertZoomSupported(Object receiver, boolean expectedEnabled) {
	92	TextZoomInHandler textZoomHandler= new TextZoomInHandler();
	93
	94	EvaluationContext evaluationContext= new EvaluationContext(null, new Object());
	95	evaluationContext.addVariable(ISources.ACTIVE_EDITOR_NAME, receiver);
	96
	97	textZoomHandler.setEnabled(evaluationContext);
	98
	99	boolean actualEnabled= textZoomHandler.isEnabled();
	100
	101	assertEquals(expectedEnabled, actualEnabled);
	102	}
	103
	104	private static class TestAbstractTextEditor extends AbstractTextEditor {
	105
	106	@Override
	107	public <T> T getAdapter(Class<T> adapter) {
	108	return null;
	109	}
	110
	111	@Override
	112	public void init(IEditorSite site, IEditorInput input) throws PartInitException { //
	113	}
	114	}
	115
	116	private static class TestNonTextEditor extends EditorPart {
	117
	118	@Override
	119	public <T> T getAdapter(Class<T> adapter) {
	120	return null;
	121	}
	122
	123	@Override
	124	public void doSave(IProgressMonitor monitor) { //
	125	}
	126
	127	@Override
	128	public void doSaveAs() { //
	129	}
	130
	131	@Override
	132	public void init(IEditorSite site, IEditorInput input) throws PartInitException { //
	133	}
	134
	135	@Override
	136	public boolean isDirty() { //
	137	return false;
	138	}
	139
	140	@Override
	141	public boolean isSaveAsAllowed() { //
	142	return false;
	143	}
	144
	145	@Override
	146	public void createPartControl(Composite parent) { //
	147	}
	148
	149	@Override
	150	public void setFocus() { //
	151	}
	152	}
	153
	154	private static class TestAdaptableToAbstractTestEditor extends TestNonTextEditor {
	155
	156	@Override
	157	public <T> T getAdapter(Class<T> adapter) {
	158	if (adapter == AbstractTextEditor.class) {
	159	return adapter.cast(new TestAbstractTextEditor());
	160	}
	161	return null;
	162	}
	163	}
	164
	165	private static class TestMultiEditor extends AbstractMultiEditor {
	166
	167	@Override
	168	public <T> T getAdapter(Class<T> adapter) {
	169	return null;
	170	}
	171
	172	public TestMultiEditor(IEditorPart child) {
	173	setChildren(new IEditorPart[] { child });
	174	}
	175
	176	@Override
	177	public void createPartControl(Composite parent) { //
	178	}
	179
	180	@Override
	181	protected void innerEditorsCreated() { //
	182	}
	183
	184	@Override
	185	public Composite getInnerEditorContainer(IEditorReference innerEditorReference) {
	186	return null;
	187	}
	188	}
	189
	190	private static class TestMultiPageEditorPart extends MultiPageEditorPart {
	191
	192	private IEditorPart child;
	193
	194	public TestMultiPageEditorPart(IEditorPart child) {
	195	this.child= child;
	196	}
	197
	198	@Override
	199	public <T> T getAdapter(Class<T> adapter) {
	200	return null;
	201	}
	202
	203	@Override
	204	public boolean isSaveAsAllowed() {
	205	return false;
	206	}
	207
	208	@Override
	209	public void doSaveAs() { //
	210	}
	211
	212	@Override
	213	public void doSave(IProgressMonitor monitor) { //
	214	}
	215
	216	@Override
	217	protected void createPages() { //
	218	}
	219
	220	@Override
	221	public void init(IEditorSite site, IEditorInput input) throws PartInitException { //
	222	}
	223
	224	@Override
	225	public Object getSelectedPage() {
	226	return child;
	227	}
	228	}
	229
	230	}

+2

-1

org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/WorkbenchTextEditorTestSuite.java less more

32	32	ChangeRegionTest.class,
33	33	RulerTestSuite.class,
34	34	HunkComputerTest.class,
35		ScreenshotTest.class
	35	ScreenshotTest.class,
	36	AbstractTextZoomHandlerTest.class
36	37	})
37	38	public class WorkbenchTextEditorTestSuite {
38	39	// see @SuiteClasses

+3

-2

pom.xml less more

14	14	<parent>
15	15	<groupId>org.eclipse</groupId>
16	16	<artifactId>eclipse-platform-parent</artifactId>
17		<version>4.7.3-SNAPSHOT</version>
	17	<version>4.8.0-SNAPSHOT</version>
18	18	<relativePath>../eclipse-platform-parent</relativePath>
19	19	</parent>
20	20
21	21	<groupId>eclipse.platform.text</groupId>
22	22	<artifactId>eclipse.platform.text</artifactId>
23		<version>4.7.3-SNAPSHOT</version>
	23	<version>4.8.0-SNAPSHOT</version>
24	24	<packaging>pom</packaging>
25	25
26	26	<properties>

64	64	<module>org.eclipse.ui.editors</module>
65	65	<module>org.eclipse.search</module>
66	66	<module>org.eclipse.ui.examples.javaeditor</module>
	67	<module>org.eclipse.jface.text.examples</module>
67	68	<!-- Generic editor -->
68	69	<module>org.eclipse.ui.genericeditor</module>
69	70	<module>org.eclipse.ui.genericeditor.tests</module>

+2

-2

tests-pom/pom.xml less more

13	13	<parent>
14	14	<artifactId>eclipse.platform.text</artifactId>
15	15	<groupId>eclipse.platform.text</groupId>
16		<version>4.7.3-SNAPSHOT</version>
	16	<version>4.8.0-SNAPSHOT</version>
17	17	</parent>
18	18	<artifactId>tests-pom</artifactId>
19		<version>4.7.3-SNAPSHOT</version>
	19	<version>4.8.0-SNAPSHOT</version>
20	20	<packaging>pom</packaging>
21	21	<properties>
22	22	<code.ignoredWarnings>${tests.ignoredWarnings}</code.ignoredWarnings>