Attachment #87659 for bug #208881

Lines 1-5 Link Here

(-)src/org/eclipse/core/filebuffers/tests/FileBuffersTestSuite.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Andrew Ferguson (Symbian)
10	*******************************************************************************/	11	*******************************************************************************/
11		12
12	package org.eclipse.core.filebuffers.tests;	13	package org.eclipse.core.filebuffers.tests;
Lines 38-43 Link Here
38	suite.addTestSuite(FileStoreFileBuffersForExternalFiles.class);	39	suite.addTestSuite(FileStoreFileBuffersForExternalFiles.class);
39	suite.addTestSuite(FileStoreFileBuffersForNonExistingExternalFiles.class);	40	suite.addTestSuite(FileStoreFileBuffersForNonExistingExternalFiles.class);
40	suite.addTestSuite(FileStoreFileBuffersForNonExistingWorkspaceFiles.class);	41	suite.addTestSuite(FileStoreFileBuffersForNonExistingWorkspaceFiles.class);
		42
		43	suite.addTestSuite(TextFileManagerDocCreationTests.class);
		44	suite.addTestSuite(ResourceTextFileManagerDocCreationTests.class);
41	//$JUnit-END$	45	//$JUnit-END$
42	return suite;	46	return suite;
43	}	47	}

Lines 1-7 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %Plugin.name	3	Bundle-Name: %Plugin.name
4	Bundle-SymbolicName: org.eclipse.core.filebuffers.tests	4	Bundle-SymbolicName: org.eclipse.core.filebuffers.tests;singleton:=true
5	Bundle-Version: 3.4.0.qualifier	5	Bundle-Version: 3.4.0.qualifier
6	Bundle-ClassPath: filebufferstests.jar	6	Bundle-ClassPath: filebufferstests.jar
7	Bundle-Activator: org.eclipse.core.filebuffers.tests.FileBuffersTestPlugin	7	Bundle-Activator: org.eclipse.core.filebuffers.tests.FileBuffersTestPlugin

Lines 13-19 Link Here

(-)build.properties (-1 / +2 lines)
13	about.html,\	13	about.html,\
14	testResources/,\	14	testResources/,\
15	*.jar,\	15	*.jar,\
16	META-INF/	16	META-INF/,\
		17	plugin.xml
17		18
18	src.includes = about.html	19	src.includes = about.html
19		20




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.core.filebuffers.tests;

import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.internal.filebuffers.ResourceTextFileBufferManager;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Path;

public class ResourceTextFileManagerDocCreationTests extends AbstractFileBufferDocCreationTests {
	protected void setUp() throws Exception {
		fManager= new ResourceTextFileBufferManager();
	}
	
	protected void assertDocumentContent(String expectedContent, String fullPath, LocationKind locKind) {
		assertEquals(expectedContent, fManager.createEmptyDocument(new Path(fullPath), locKind).get());
		if(locKind.equals(LocationKind.IFILE)) {
			IFile file= ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(fullPath));
			assertEquals(expectedContent, ((ResourceTextFileBufferManager)fManager).createEmptyDocument(file).get());
		}
	}
	
	protected LocationKind[] getSupportLocationKinds() {
		return new LocationKind[] {LocationKind.IFILE, LocationKind.LOCATION, LocationKind.NORMALIZE};
	}
}




<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.2"?>
<!--
  -
  - Register IDocumentSetupParticipants against names and extensions that won't interfere with
  - normal operation.
  -
  -->
<plugin>
<!-- IDocumentSetupParticipant -->
   <extension point="org.eclipse.core.filebuffers.documentSetup">
      <participant
            class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP1"
            extensions="111foo">
      </participant>
   </extension>
   <extension point="org.eclipse.core.filebuffers.documentSetup">
      <participant
            class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP2"
            fileNames="111fooname,111fooname.111foo">
      </participant>
   </extension>  
   <extension point="org.eclipse.core.filebuffers.documentSetup">
      <participant
            class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP3"
            extensions="111foo"
            fileNames="111fooname,111fooname.111foo">
      </participant>
   </extension>
   
   <!-- IDocumentSetupParticipantExtension ignoring hint -->
   <extension point="org.eclipse.core.filebuffers.documentSetup">
      <participant
            class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP4"
            extensions="222foo">
      </participant>
   </extension>
   <extension point="org.eclipse.core.filebuffers.documentSetup">
      <participant
            class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP5"
            fileNames="222fooname,222fooname.222foo">
      </participant>
   </extension>
   <extension point="org.eclipse.core.filebuffers.documentSetup">
      <participant
            class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP6"
            extensions="222foo"
            fileNames="222fooname,222fooname.222foo">
      </participant>
   </extension>
   
   <!-- IDocumentSetupPartcipantExtension selectively picking up hint -->
   <extension point="org.eclipse.core.filebuffers.documentSetup">
      <participant
            class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP7"
            extensions="333foo"
            fileNames="333fooname,333fooname.333foo">
      </participant>
   </extension>
   <extension point="org.eclipse.core.filebuffers.documentSetup">
      <participant
            class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP8"
            extensions="444foo"
            fileNames="444fooname,444fooname.444foo">
      </participant>
   </extension>
   <extension point="org.eclipse.core.filebuffers.documentSetup">
      <participant
            class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP9"
            extensions="555foo"
            fileNames="555fooname,555fooname.555foo">
      </participant>
   </extension>
</plugin>
 




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.core.filebuffers.tests;

import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.internal.filebuffers.TextFileBufferManager;

public class TextFileManagerDocCreationTests extends AbstractFileBufferDocCreationTests {
	protected void setUp() throws Exception {
		fManager= new TextFileBufferManager();
	}
	
	protected void assertDocumentContent(String expectedContent, String path,
			LocationKind locKind) {
		if(!locKind.equals(LocationKind.IFILE)) {
			/**  {@link TextFileBufferManager} does not deal with {@link LocationKind#IFILE} */
			super.assertDocumentContent(expectedContent, path, locKind);
		}
	}
	
	protected LocationKind[] getSupportLocationKinds() {
		return new LocationKind[] {LocationKind.LOCATION, LocationKind.NORMALIZE};
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.core.filebuffers.tests;

import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
import org.eclipse.core.filebuffers.IDocumentSetupParticipantExtension;
import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;

/**
 * Holds {@link IDocumentSetupParticipant}'s for registering against fictional
 * document extensions for test purposes.
 */
public class MockDocumentSetupParticipants {
	/**
	 * An {@link IDocumentSetupParticipant} which stamps its name
	 * into the document being setup for integration test purposes.
	 */
	static abstract class AbstractTestDSP implements IDocumentSetupParticipant {
		/*
		 * @see org.eclipse.core.filebuffers.IDocumentSetupParticipant#setup(org.eclipse.jface.text.IDocument)
		 */
		public void setup(IDocument document) {
			append(document, getClass()+"\n");
		}
	}
	
	static abstract class AbstractTestDSPExtension extends AbstractTestDSP implements IDocumentSetupParticipant, IDocumentSetupParticipantExtension {
		/*
		 * @see org.eclipse.core.filebuffers.IDocumentSetupParticipantExtension#setup(org.eclipse.jface.text.IDocument, org.eclipse.core.runtime.IPath, org.eclipse.core.filebuffers.LocationKind)
		 */
		public void setup(IDocument document, IPath location, LocationKind locationKind) {
			append(document, getClass()+"%%EXTENSION\n");
		}
	}
	
	public static class TestDSP1 extends AbstractTestDSP {}
	public static class TestDSP2 extends AbstractTestDSP {}
	public static class TestDSP3 extends AbstractTestDSP {}
	
	public static class TestDSP4 extends AbstractTestDSPExtension {}
	public static class TestDSP5 extends AbstractTestDSPExtension {}
	public static class TestDSP6 extends AbstractTestDSPExtension {}
	
	public static class TestDSP7 extends AbstractTestDSPExtension {
		public void setup(IDocument document, IPath location, LocationKind locationKind) {
			if(location!=null && LocationKind.IFILE.equals(locationKind)) {
				append(document, new StringBuffer(location.toPortableString()).reverse().toString());
			}
		}
	}
	
	public static class TestDSP8 extends AbstractTestDSPExtension {
		public void setup(IDocument document, IPath location, LocationKind locationKind) {
			if(location!=null && LocationKind.LOCATION.equals(locationKind)) {
				append(document, new StringBuffer(location.toPortableString()).reverse().toString());
			}
		}
	}
	
	public static class TestDSP9 extends AbstractTestDSPExtension {
		public void setup(IDocument document, IPath location, LocationKind locationKind) {
			if(location!=null && LocationKind.NORMALIZE.equals(locationKind)) {
				append(document, new StringBuffer(location.toPortableString()).reverse().toString());
			}
		}
	}
	
	private static void append(IDocument document, String string) {
		try {
			document.replace(document.getLength(), 0, string);
		} catch(BadLocationException ble) {
			Assert.isTrue(false);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.core.filebuffers.tests;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

import junit.framework.TestCase;

import org.eclipse.core.filebuffers.IDocumentSetupParticipantExtension;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants.TestDSP1;
import org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants.TestDSP2;
import org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants.TestDSP3;
import org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants.TestDSP4;
import org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants.TestDSP5;
import org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants.TestDSP6;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.text.IDocument;

public abstract class AbstractFileBufferDocCreationTests extends TestCase {
	protected ITextFileBufferManager fManager;
	
	
	public void testCreateDocumentPartipants_FileExt() {
		assertParticipantsInvoked("anything.111foo", new Class[] {TestDSP1.class, TestDSP3.class});
	}
	
	public void testCreateDocumentPartipants_Name() {
		assertParticipantsInvoked("111fooname", new Class[] {TestDSP2.class, TestDSP3.class});
	}
	
	public void testCreateDocumentPartipants_FileExt_Name() {
		assertParticipantsInvoked("111fooname.111foo", new Class[] {TestDSP1.class, TestDSP2.class, TestDSP3.class});
	}
	
	public void testCreateDocumentPartipants_FileExt_Extension() {
		assertParticipantsInvoked("anything.222foo", new Class[] {TestDSP4.class, TestDSP6.class});
	}
	
	public void testCreateDocumentPartipants_Name_Extension() {
		assertParticipantsInvoked("222fooname", new Class[] {TestDSP5.class, TestDSP6.class});
	}
	
	public void testCreateDocumentPartipants_FileExt_Name_Extension() {
		assertParticipantsInvoked("222fooname.222foo", new Class[] {TestDSP4.class, TestDSP5.class, TestDSP6.class});
	}
	
	public void testDocumentSetupParticipantExtension_1() {
		assertDocumentContent("emanoof333/p/", "/p/333fooname", LocationKind.IFILE);
		assertDocumentContent("oof333.emanoof333/p/", "/p/333fooname.333foo", LocationKind.IFILE);
		assertDocumentContent("oof333.gnihtyna/p/", "/p/anything.333foo", LocationKind.IFILE);
		
		assertDocumentContent("", "333fooname", LocationKind.LOCATION);
		assertDocumentContent("", "333fooname.333foo", LocationKind.LOCATION);
		assertDocumentContent("", "anything.333foo", LocationKind.LOCATION);
		
		assertDocumentContent("", "333fooname", LocationKind.NORMALIZE);
		assertDocumentContent("", "333fooname.333foo", LocationKind.NORMALIZE);
		assertDocumentContent("", "anything.333foo", LocationKind.NORMALIZE);
	}
	
	public void testDocumentSetupParticipantExtension_2() {
		assertDocumentContent("", "/p/444fooname", LocationKind.IFILE);
		assertDocumentContent("", "/p/444fooname.444foo", LocationKind.IFILE);
		assertDocumentContent("", "/p/anything.444foo", LocationKind.IFILE);
		
		assertDocumentContent("emanoof444", "444fooname", LocationKind.LOCATION);
		assertDocumentContent("oof444.emanoof444", "444fooname.444foo", LocationKind.LOCATION);
		assertDocumentContent("oof444.gnihtyna", "anything.444foo", LocationKind.LOCATION);
		
		assertDocumentContent("", "444fooname", LocationKind.NORMALIZE);
		assertDocumentContent("", "444fooname.444foo", LocationKind.NORMALIZE);
		assertDocumentContent("", "anything.444foo", LocationKind.NORMALIZE);
	}
	
	public void testDocumentSetupParticipantExtension_3() {
		assertDocumentContent("", "/p/555fooname", LocationKind.IFILE);
		assertDocumentContent("", "/p/555fooname.555foo", LocationKind.IFILE);
		assertDocumentContent("", "/p/anything.555foo", LocationKind.IFILE);
		
		assertDocumentContent("", "555fooname", LocationKind.LOCATION);
		assertDocumentContent("", "555fooname.555foo", LocationKind.LOCATION);
		assertDocumentContent("", "anything.555foo", LocationKind.LOCATION);
		
		assertDocumentContent("emanoof555", "555fooname", LocationKind.NORMALIZE);
		assertDocumentContent("oof555.emanoof555", "555fooname.555foo", LocationKind.NORMALIZE);
		assertDocumentContent("oof555.gnihtyna", "anything.555foo", LocationKind.NORMALIZE);
	}
	
	/* Utilities */
	
	private void assertParticipantsInvoked(String path, Class[] expectedDSPsArray) {
		LocationKind[] lks= getSupportLocationKinds();
		for(int i=0; i<lks.length; i++) {
			IDocument document= fManager.createEmptyDocument(new Path(path), lks[i]);		
			String content= document.get();
			Set expectedDSPs= new HashSet(Arrays.asList(toString(expectedDSPsArray)));
			Set actualDSPs= new HashSet(Arrays.asList(content.split("\n")));
			assertEquals(expectedDSPs, actualDSPs);
		}
	}
	
	abstract protected LocationKind[] getSupportLocationKinds();
	
	protected void assertDocumentContent(String expectedContent, String path, LocationKind locKind) {
		assertEquals(expectedContent, fManager.createEmptyDocument(new Path(path), locKind).get());
	}
	
	private static String[] toString(Class[] clss) {
		String[] result= new String[clss.length];
		for(int i=0; i<result.length; i++) {
			String s= null;
			if(clss[i]!=null) {
				s= clss[i].toString();
				if(IDocumentSetupParticipantExtension.class.isAssignableFrom(clss[i])) {
					s+= "%%EXTENSION";
				}
			}
			result[i]= s;
		}
		return result;
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/cdt/core/ICDescriptor.java (-1 / +19 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 QNX Software Systems and others.	2	* Copyright (c) 2000, 2008 QNX Software Systems and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 15-23 Link Here
15	import org.eclipse.core.runtime.CoreException;	15	import org.eclipse.core.runtime.CoreException;
16	import org.w3c.dom.Element;	16	import org.w3c.dom.Element;
17		17
		18	/**
		19	* Models meta-data stored with a CDT project
		20	*/
18	public interface ICDescriptor {	21	public interface ICDescriptor {
19	public ICOwnerInfo getProjectOwner();	22	public ICOwnerInfo getProjectOwner();
20	public String getPlatform();	23	public String getPlatform();
		24
		25	/**
		26	* @return the associated project
		27	*/
21	public IProject getProject();	28	public IProject getProject();
22		29
23	public ICExtensionReference[] get(String extensionPoint);	30	public ICExtensionReference[] get(String extensionPoint);
Lines 27-33 Link Here
27	public void remove(ICExtensionReference extension) throws CoreException;	34	public void remove(ICExtensionReference extension) throws CoreException;
28	public void remove(String extensionPoint) throws CoreException;	35	public void remove(String extensionPoint) throws CoreException;
29		36
		37	/**
		38	* @param id an identifier that uniquely identifies the client
		39	* @return a non-null {@link Element} to which client specific meta-data may be attached
		40	* @throws CoreException
		41	*/
30	public Element getProjectData(String id) throws CoreException;	42	public Element getProjectData(String id) throws CoreException;
		43
		44	/**
		45	* Saves any changes made to {@link Element} objects obtained from {@link #getProjectData(String)}
		46	* to a CDT defined project meta-data file.
		47	* @throws CoreException
		48	*/
31	public void saveProjectData() throws CoreException;	49	public void saveProjectData() throws CoreException;
32		50
33	ICConfigurationDescription getConfigurationDescription();	51	ICConfigurationDescription getConfigurationDescription();




/*******************************************************************************
 * Copyright (c) 2000, 2005, 2007 IBM Corporation and others.
 * 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

 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     QNX Software System
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import java.util.List;

import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.Token;

import org.eclipse.cdt.ui.text.ITokenStoreFactory;


/**
 * 
 */
public final class SingleTokenCScanner extends AbstractCScanner {
	
	protected IToken fDefaultReturnToken;
	private String[] fProperty;
	
	public SingleTokenCScanner(ITokenStoreFactory factory, String property) {
		super(factory.createTokenStore(new String[] {property}), 20);
		fProperty= new String[] { property };
		setRules(createRules());
	}

	/*




 *     IBM Corporation - initial API and implementation
 *     QNX Software System
 *     Anton Leherbauer (Wind River Systems)
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

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

import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.jface.text.rules.WhitespaceRule;
import org.eclipse.jface.text.rules.WordRule;
import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.cdt.core.model.ICLanguageKeywords;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;

import org.eclipse.cdt.internal.ui.text.util.CWhitespaceDetector;
import org.eclipse.cdt.internal.ui.text.util.CWordDetector;


	/**
	 * Creates a C/C++ code scanner.
	 * @param factory 
     * @param manager  the color manager
     * @param store  the reference store
     * @param keywords  the keywords defined by the language dialect
	 */
	public CCodeScanner(ITokenStoreFactory factory, ICLanguageKeywords keywords) {
		super(factory.createTokenStore(fgTokenProperties));
		fKeywords= keywords;
		setRules(createRules());
	}
	
	/*
	 * @see AbstractCScanner#getTokenProperties()
	 */
	protected String[] getTokenProperties() {
		return fgTokenProperties;
	}

	/*
	 * @see AbstractCScanner#createRules()
	 */
	protected List createRules() {
				
		List rules= new ArrayList();		
		IToken token;
		
		// Add generic white space rule.
		rules.add(new WhitespaceRule(new CWhitespaceDetector()));

		setDefaultReturnToken(getToken(ICColorConstants.C_DEFAULT));
		return rules;
	}

	/*
	 * @see AbstractCScanner#adaptToPreferenceChange(PropertyChangeEvent)
	 */
	public void adaptToPreferenceChange(PropertyChangeEvent event) {
		if (super.affectsBehavior(event)) {
			super.adaptToPreferenceChange(event);
		}
	}
}

Lines 9-17 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/CTextTools.java (-83 / +115 lines)
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* QNX Software System	10	* QNX Software System
11	* Anton Leherbauer (Wind River Systems)	11	* Anton Leherbauer (Wind River Systems)
		12	* Andrew Ferguson (Symbian)
12	*******************************************************************************/	13	*******************************************************************************/
13	package org.eclipse.cdt.internal.ui.text;	14	package org.eclipse.cdt.internal.ui.text;
14		15
		16	import org.eclipse.core.filebuffers.LocationKind;
		17	import org.eclipse.core.resources.IFile;
		18	import org.eclipse.core.resources.ResourcesPlugin;
		19	import org.eclipse.core.runtime.IPath;
15	import org.eclipse.core.runtime.Preferences;	20	import org.eclipse.core.runtime.Preferences;
16	import org.eclipse.jface.preference.IPreferenceStore;	21	import org.eclipse.jface.preference.IPreferenceStore;
17	import org.eclipse.jface.text.IDocument;	22	import org.eclipse.jface.text.IDocument;
Lines 26-32 Link Here
26	import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;	31	import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
27	import org.eclipse.cdt.ui.CUIPlugin;	32	import org.eclipse.cdt.ui.CUIPlugin;
28	import org.eclipse.cdt.ui.text.ICPartitions;	33	import org.eclipse.cdt.ui.text.ICPartitions;
		34	import org.eclipse.cdt.ui.text.ITokenStore;
		35	import org.eclipse.cdt.ui.text.ITokenStoreFactory;
		36	import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
29		37
		38	import org.eclipse.cdt.internal.ui.text.doctools.DocCommentOwnerManager;
30	import org.eclipse.cdt.internal.ui.text.util.CColorManager;	39	import org.eclipse.cdt.internal.ui.text.util.CColorManager;
31		40
32		41
Lines 35-48 Link Here
35	* its clients.	44	* its clients.
36	*/	45	*/
37	public class CTextTools {	46	public class CTextTools {
38		47
39	private class PreferenceListener implements IPropertyChangeListener, Preferences.IPropertyChangeListener {	48	private class PreferenceListener implements IPropertyChangeListener, Preferences.IPropertyChangeListener {
40	public void propertyChange(PropertyChangeEvent event) {	49	public void propertyChange(PropertyChangeEvent event) {
41	adaptToPreferenceChange(event);	50	adaptToPreferenceChange(event);
42	}	51	}
43	public void propertyChange(Preferences.PropertyChangeEvent event) {	52	public void propertyChange(Preferences.PropertyChangeEvent event) {
44	adaptToPreferenceChange(new PropertyChangeEvent(event.getSource(), event.getProperty(), event.getOldValue(), event.getNewValue()));	53	adaptToPreferenceChange(new PropertyChangeEvent(event.getSource(), event.getProperty(), event.getOldValue(), event.getNewValue()));
45	}	54	}
46	}	55	}
47		56
48	/** The color manager */	57	/** The color manager */
Lines 64-120 Link Here
64		73
65	/** The preference store */	74	/** The preference store */
66	private IPreferenceStore fPreferenceStore;	75	private IPreferenceStore fPreferenceStore;
67	/** The core preference store */	76	/** The core preference store */
68	private Preferences fCorePreferenceStore;	77	private Preferences fCorePreferenceStore;
69	/** The preference change listener */	78	/** The preference change listener */
70	private PreferenceListener fPreferenceListener= new PreferenceListener();	79	private PreferenceListener fPreferenceListener= new PreferenceListener();
71	/** The document partitioning used for the C partitioner */	80	/** The document partitioning used for the C partitioner */
72	private String fDocumentPartitioning = ICPartitions.C_PARTITIONING;	81	private String fDocumentPartitioning = ICPartitions.C_PARTITIONING;
73		82
		83	/**
		84	* Creates a new C text tools collection and eagerly creates
		85	* and initializes all members of this collection.
		86	*/
		87	public CTextTools(IPreferenceStore store) {
		88	this(store, null, true);
		89	}
		90
74	/**	91	/**
75	* Creates a new C text tools collection and eagerly creates	92	* Creates a new C text tools collection and eagerly creates
76	* and initializes all members of this collection.	93	* and initializes all members of this collection.
77	*/	94	*/
78	public CTextTools(IPreferenceStore store) {	95	public CTextTools(IPreferenceStore store, Preferences coreStore) {
79	this(store, null, true);	96	this(store, coreStore, true);
80	}	97	}
81		98
82	/**	99	/**
83	* Creates a new C text tools collection and eagerly creates	100	* Creates a new C text tools collection and eagerly creates
84	* and initializes all members of this collection.	101	* and initializes all members of this collection.
85	*/	102	*/
86	public CTextTools(IPreferenceStore store, Preferences coreStore) {
87	this(store, coreStore, true);
88	}
89
90	/**
91	* Creates a new C text tools collection and eagerly creates
92	* and initializes all members of this collection.
93	*/
94	public CTextTools(IPreferenceStore store, Preferences coreStore, boolean autoDisposeOnDisplayDispose) {	103	public CTextTools(IPreferenceStore store, Preferences coreStore, boolean autoDisposeOnDisplayDispose) {
95	if(store == null) {	104	fPreferenceStore = store != null ? store : CUIPlugin.getDefault().getPreferenceStore();
96	store = CUIPlugin.getDefault().getPreferenceStore();
97	}
98	fColorManager= new CColorManager(autoDisposeOnDisplayDispose);	105	fColorManager= new CColorManager(autoDisposeOnDisplayDispose);
99	fCodeScanner= new CCodeScanner(fColorManager, store, GCCLanguage.getDefault());
100	fCppCodeScanner= new CCodeScanner(fColorManager, store, GPPLanguage.getDefault());
101
102	fMultilineCommentScanner= new CCommentScanner(fColorManager, store, coreStore, ICColorConstants.C_MULTI_LINE_COMMENT);
103	fSinglelineCommentScanner= new CCommentScanner(fColorManager, store, coreStore, ICColorConstants.C_SINGLE_LINE_COMMENT);
104	fStringScanner= new SingleTokenCScanner(fColorManager, store, ICColorConstants.C_STRING);
105	fCPreprocessorScanner= new CPreprocessorScanner(fColorManager, store, GCCLanguage.getDefault());
106	fCppPreprocessorScanner= new CPreprocessorScanner(fColorManager, store, GPPLanguage.getDefault());
107		106
108	fPreferenceStore = store;	107	ITokenStoreFactory factory= new ITokenStoreFactory() {
		108	public ITokenStore createTokenStore(String[] propertyColorNames) {
		109	return new TokenStore(getColorManager(), fPreferenceStore, propertyColorNames);
		110	}
		111	};
		112
		113	fMultilineCommentScanner= new CCommentScanner(factory, coreStore, ICColorConstants.C_MULTI_LINE_COMMENT);
		114	fSinglelineCommentScanner= new CCommentScanner(factory, coreStore, ICColorConstants.C_SINGLE_LINE_COMMENT);
		115	fCodeScanner= new CCodeScanner(factory, GCCLanguage.getDefault());
		116	fCppCodeScanner= new CCodeScanner(factory, GPPLanguage.getDefault());
		117
		118	fStringScanner= new SingleTokenCScanner(factory, ICColorConstants.C_STRING);
		119	fCPreprocessorScanner= new CPreprocessorScanner(factory, GCCLanguage.getDefault());
		120	fCppPreprocessorScanner= new CPreprocessorScanner(factory, GPPLanguage.getDefault());
		121
109	fPreferenceStore.addPropertyChangeListener(fPreferenceListener);	122	fPreferenceStore.addPropertyChangeListener(fPreferenceListener);
110		123
111	fCorePreferenceStore= coreStore;	124	fCorePreferenceStore= coreStore;
112	if (fCorePreferenceStore != null) {	125	if (fCorePreferenceStore != null) {
113	fCorePreferenceStore.addPropertyChangeListener(fPreferenceListener);	126	fCorePreferenceStore.addPropertyChangeListener(fPreferenceListener);
114	}	127	}
115
116	}	128	}
117		129
118	/**	130	/**
119	* Creates a new C text tools collection and eagerly creates	131	* Creates a new C text tools collection and eagerly creates
120	* and initializes all members of this collection.	132	* and initializes all members of this collection.
Lines 122-204 Link Here
122	public CTextTools() {	134	public CTextTools() {
123	this((IPreferenceStore)null);	135	this((IPreferenceStore)null);
124	}	136	}
125		137
126	/**	138	/**
127	* Disposes all members of this tools collection.	139	* Disposes all members of this tools collection.
128	*/	140	*/
129	public void dispose() {	141	public void dispose() {
130		142
131	fCodeScanner= null;	143	fCodeScanner= null;
132	fMultilineCommentScanner= null;	144	fMultilineCommentScanner= null;
133	fSinglelineCommentScanner= null;	145	fSinglelineCommentScanner= null;
134	fStringScanner= null;	146	fStringScanner= null;
135		147
136	if (fColorManager != null) {	148	if (fColorManager != null) {
137	fColorManager.dispose();	149	fColorManager.dispose();
138	fColorManager= null;	150	fColorManager= null;
139	}	151	}
140		152
141	if (fPreferenceStore != null) {	153	if (fPreferenceStore != null) {
142	fPreferenceStore.removePropertyChangeListener(fPreferenceListener);	154	fPreferenceStore.removePropertyChangeListener(fPreferenceListener);
143	fPreferenceStore= null;	155	fPreferenceStore= null;
144		156
145	if (fCorePreferenceStore != null) {	157	if (fCorePreferenceStore != null) {
146	fCorePreferenceStore.removePropertyChangeListener(fPreferenceListener);	158	fCorePreferenceStore.removePropertyChangeListener(fPreferenceListener);
147	fCorePreferenceStore= null;	159	fCorePreferenceStore= null;
148	}	160	}
149		161
150	fPreferenceListener= null;	162	fPreferenceListener= null;
151	}	163	}
152	}	164	}
153		165
154	/**	166	/**
155	* Gets the color manager.	167	* Gets the color manager.
156	*/	168	*/
157	public CColorManager getColorManager() {	169	public CColorManager getColorManager() {
158	return fColorManager;	170	return fColorManager;
159	}	171	}
160		172
161	/**	173	/**
162	* Gets the code scanner used.	174	* Gets the code scanner used.
163	*/	175	*/
164	public RuleBasedScanner getCCodeScanner() {	176	public RuleBasedScanner getCCodeScanner() {
165	return fCodeScanner;	177	return fCodeScanner;
166	}	178	}
167		179
168	/**	180	/**
169	* Gets the code scanner used.	181	* Gets the code scanner used.
170	*/	182	*/
171	public RuleBasedScanner getCppCodeScanner() {	183	public RuleBasedScanner getCppCodeScanner() {
172	return fCppCodeScanner;	184	return fCppCodeScanner;
173	}	185	}
174		186
175	/**	187	/**
176	* Returns a scanner which is configured to scan	188	* Returns a scanner which is configured to scan
177	* C-specific partitions, which are multi-line comments,	189	* C-specific partitions, which are multi-line comments,
178	* and regular C source code.	190	* and regular C source code.
179	*	191	*
		192	* @param owner may be null
180	* @return a C partition scanner	193	* @return a C partition scanner
181	*/	194	*/
182	public IPartitionTokenScanner getPartitionScanner() {	195	public IPartitionTokenScanner getPartitionScanner(IDocCommentOwner owner) {
183	return new FastCPartitionScanner();	196	return new FastCPartitionScanner(owner);
184	}	197	}
185		198
186	/**	199	/**
187	* Gets the document provider used.	200	* Gets the document provider used.
188	*/	201	*/
189	public IDocumentPartitioner createDocumentPartitioner() {	202	public IDocumentPartitioner createDocumentPartitioner(IDocCommentOwner owner) {
190		203	return new FastCPartitioner(getPartitionScanner(owner), ICPartitions.ALL_CPARTITIONS);
191	String[] types= new String[] {
192	ICPartitions.C_MULTI_LINE_COMMENT,
193	ICPartitions.C_SINGLE_LINE_COMMENT,
194	ICPartitions.C_STRING,
195	ICPartitions.C_CHARACTER,
196	ICPartitions.C_PREPROCESSOR
197	};
198
199	return new FastCPartitioner(getPartitionScanner(), types);
200	}	204	}
201		205
202	/**	206	/**
203	* Returns a scanner which is configured to scan C multiline comments.	207	* Returns a scanner which is configured to scan C multiline comments.
204	*	208	*
Lines 216-222 Link Here
216	public RuleBasedScanner getSinglelineCommentScanner() {	220	public RuleBasedScanner getSinglelineCommentScanner() {
217	return fSinglelineCommentScanner;	221	return fSinglelineCommentScanner;
218	}	222	}
219		223
220	/**	224	/**
221	* Returns a scanner which is configured to scan C strings.	225	* Returns a scanner which is configured to scan C strings.
222	*	226	*
Lines 243-249 Link Here
243	public RuleBasedScanner getCppPreprocessorScanner() {	247	public RuleBasedScanner getCppPreprocessorScanner() {
244	return fCppPreprocessorScanner;	248	return fCppPreprocessorScanner;
245	}	249	}
246		250
247	/**	251	/**
248	* Determines whether the preference change encoded by the given event	252	* Determines whether the preference change encoded by the given event
249	* changes the behavior of one its contained components.	253	* changes the behavior of one its contained components.
Lines 253-265 Link Here
253	*/	257	*/
254	public boolean affectsBehavior(PropertyChangeEvent event) {	258	public boolean affectsBehavior(PropertyChangeEvent event) {
255	return fCodeScanner.affectsBehavior(event) \|\|	259	return fCodeScanner.affectsBehavior(event) \|\|
256	fCppCodeScanner.affectsBehavior(event) \|\|	260	fCppCodeScanner.affectsBehavior(event) \|\|
257	fMultilineCommentScanner.affectsBehavior(event) \|\|	261	fMultilineCommentScanner.affectsBehavior(event) \|\|
258	fSinglelineCommentScanner.affectsBehavior(event) \|\|	262	fSinglelineCommentScanner.affectsBehavior(event) \|\|
259	fStringScanner.affectsBehavior(event) \|\|	263	fStringScanner.affectsBehavior(event) \|\|
260	fCPreprocessorScanner.affectsBehavior(event);	264	fCPreprocessorScanner.affectsBehavior(event);
261	}	265	}
262		266
263	/**	267	/**
264	* Adapts the behavior of the contained components to the change	268	* Adapts the behavior of the contained components to the change
265	* encoded in the given event.	269	* encoded in the given event.
Lines 286-297 Link Here
286	/**	290	/**
287	* Sets up the document partitioner for the given document for the given partitioning.	291	* Sets up the document partitioner for the given document for the given partitioning.
288	*	292	*
289	* @param document the document to be set up	293	* @param document
290	* @param partitioning the document partitioning	294	* @param partitioning
291	* @since 3.0	295	* @param owner may be null
		296	* @since 5.0
292	*/	297	*/
293	public void setupCDocumentPartitioner(IDocument document, String partitioning) {	298	public void setupCDocumentPartitioner(IDocument document, String partitioning, IDocCommentOwner owner) {
294	IDocumentPartitioner partitioner= createDocumentPartitioner();	299	IDocumentPartitioner partitioner= createDocumentPartitioner(owner);
295	if (document instanceof IDocumentExtension3) {	300	if (document instanceof IDocumentExtension3) {
296	IDocumentExtension3 extension3= (IDocumentExtension3) document;	301	IDocumentExtension3 extension3= (IDocumentExtension3) document;
297	extension3.setDocumentPartitioner(partitioning, partitioner);	302	extension3.setDocumentPartitioner(partitioning, partitioner);
Lines 300-306 Link Here
300	}	305	}
301	partitioner.connect(document);	306	partitioner.connect(document);
302	}	307	}
303		308
		309	/**
		310	* Sets up the given document for the default partitioning.
		311	*
		312	* @param document the document to be set up
		313	* @param location the path of the resource backing the document. May be null.
		314	* @param locationKind the type of path specified above. May be null.
		315	* @since 3.0
		316	*/
		317	public void setupCDocument(IDocument document, IPath location, LocationKind locationKind) {
		318	IDocCommentOwner owner= getDocumentationCommentOwner(location, locationKind);
		319	setupCDocumentPartitioner(document, fDocumentPartitioning, owner);
		320	}
		321
304	/**	322	/**
305	* Sets up the given document for the default partitioning.	323	* Sets up the given document for the default partitioning.
306	*	324	*
Lines 308-314 Link Here
308	* @since 3.0	326	* @since 3.0
309	*/	327	*/
310	public void setupCDocument(IDocument document) {	328	public void setupCDocument(IDocument document) {
311	setupCDocumentPartitioner(document, fDocumentPartitioning);	329	setupCDocumentPartitioner(document, fDocumentPartitioning, null);
312	}	330	}
313		331
314	/**	332	/**
Lines 329-333 Link Here
329	public void setDocumentPartitioning(String documentPartitioning) {	347	public void setDocumentPartitioning(String documentPartitioning) {
330	fDocumentPartitioning = documentPartitioning;	348	fDocumentPartitioning = documentPartitioning;
331	}	349	}
332		350
		351	/**
		352	* @param location
		353	* @param locationKind
		354	* @return the documentation comment owner mapped to the specified location. If there is
		355	* no mapping, or the <code>location</code>/<code>locationKind</code> is not available, the
		356	* workspace default is returned.
		357	*/
		358	private IDocCommentOwner getDocumentationCommentOwner(IPath location, LocationKind locationKind) {
		359	if(location!=null && LocationKind.IFILE.equals(locationKind)) {
		360	IFile file= ResourcesPlugin.getWorkspace().getRoot().getFile(location);
		361	return DocCommentOwnerManager.getInstance().getCommentOwner(file);
		362	}
		363	return DocCommentOwnerManager.getInstance().getWorkspaceCommentOwner();
		364	}
333	}	365	}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     QNX Software System
 *     Anton Leherbauer (Wind River Systems) - Fixed bug 48339
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy;
import org.eclipse.jface.text.DocumentCommand;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;

/**
 * Auto indent strategy for C/C++ multiline comments
 */
public class CCommentAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {

	public CCommentAutoIndentStrategy() {
	}

	/**
	 * Returns whether the text ends with one of the given search strings.
	 */
	private boolean endsWithDelimiter(IDocument d, String txt) {
		String[] delimiters= d.getLegalLineDelimiters();
		
		for (int i= 0; i < delimiters.length; i++) {
			if (txt.endsWith(delimiters[i]))
				return true;
		}
		
		return false;
	}

	/**
	 * Copies the indentation of the previous line and adds a star.
	 * If the comment just started on this line adds also a blank.
	 *
	 * @param d the document to work on
	 * @param c the command to deal with
	 */
	static void commentIndentAfterNewLine(IDocument d, DocumentCommand c) {
		
		if (c.offset == -1 || d.getLength() == 0)
			return;
			
		try {
			// find start of line
			IRegion info= d.getLineInformationOfOffset(c.offset);
			int start= info.getOffset();
				
			// find white spaces
			int end= findEndOfWhiteSpaceAt(d, start, c.offset);
							
			StringBuffer buf= new StringBuffer(c.text);
			if (end >= start) {	// 1GEYL1R: ITPJUI:ALL - java doc edit smartness not work for class comments
				// append to input
				buf.append(d.get(start, end - start));				
				if (end < c.offset) {
					if (d.getChar(end) == '/') {
						// comment started on this line
						buf.append(" * ");	 //$NON-NLS-1$
					} else if (d.getChar(end) == '*') {
						buf.append("* "); //$NON-NLS-1$
					}
				}			
			}

			
			c.text= buf.toString();
				
		} catch (BadLocationException excp) {
			// stop work
		}	
	}	
	
	static int findEndOfWhiteSpaceAt(IDocument document, int offset, int end) throws BadLocationException {
		while (offset < end) {
			char c= document.getChar(offset);
			if (c != ' ' && c != '\t') {
				return offset;
			}
			offset++;
		}
		return end;
	}

	static void commentIndentForCommentEnd(IDocument d, DocumentCommand c) {
		if (c.offset < 2 || d.getLength() == 0) {
			return;
		}
		try {
			if ("* ".equals(d.get(c.offset - 2, 2))) { //$NON-NLS-1$
				// modify document command
				c.length++;
				c.offset--;
			}					
		} catch (BadLocationException excp) {
			// stop work
		}
	}

	/*
	 * @see IAutoIndentStrategy#customizeDocumentCommand
	 */
	public void customizeDocumentCommand(IDocument d, DocumentCommand c) {
		if (c.length == 0 && c.text != null && endsWithDelimiter(d, c.text))
			commentIndentAfterNewLine(d, c);
		else if ("/".equals(c.text)) { //$NON-NLS-1$
			commentIndentForCommentEnd(d, c);
		}
	}
}





 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Anton Leherbauer (Wind River Systems)
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import java.util.Collections;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import org.eclipse.cdt.core.CCorePreferenceConstants;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.IWordDetector;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.jface.text.rules.WordRule;
import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.cdt.ui.PreferenceConstants;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;
import org.eclipse.cdt.ui.text.TaskTagRule;

/**
 * Default token-scanner used for plain (non-documentation-comment) single and multi-line comments, with awareness of
 * task tags.
 */
public class CCommentScanner extends AbstractCScanner {
	private static String TASK_TAG_KEY= PreferenceConstants.EDITOR_TASK_TAG_COLOR;
	private Preferences fCorePreferenceStore;
		
	public CCommentScanner(ITokenStoreFactory tokenStoreFactory, String defaultTokenProperty) {
		this(tokenStoreFactory, null, defaultTokenProperty, new String[] { defaultTokenProperty, TASK_TAG_KEY });
	}

	public CCommentScanner(ITokenStoreFactory tokenStoreFactory, Preferences coreStore, String defaultTokenProperty) {
		this(tokenStoreFactory, coreStore, defaultTokenProperty, new String[] { defaultTokenProperty, TASK_TAG_KEY });
	}

	private CCommentScanner(ITokenStoreFactory tokenStoreFactory, Preferences coreStore, String defaultTokenProperty, String[] tokenProperties) {
		super(tokenStoreFactory.createTokenStore(tokenProperties));
		fCorePreferenceStore= coreStore;
		setRules(createRules(defaultTokenProperty));
	}

	 protected List createRules(String defaultTokenProperty) {
		 setDefaultReturnToken(getToken(defaultTokenProperty));
		 
		 IPreferenceStore store= fTokenStore.getPreferenceStore();
		 String taskWords= TaskTagRule.getTaskWords(store, fCorePreferenceStore);
		 TaskTagRule taskTagRule= new TaskTagRule(getToken(TASK_TAG_KEY), taskWords);
		 addPropertyChangeParticipant(taskTagRule);
		 return Collections.singletonList(taskTagRule);
	 }
            String[] tasks= split(value, ","); //$NON-NLS-1$
            for (int i= 0; i < tasks.length; i++) {
                if (tasks[i].length() > 0) {
                    addWord(tasks[i], fToken);
                }
            }
        }
        
        private String[] split(String value, String delimiters) {
            StringTokenizer tokenizer= new StringTokenizer(value, delimiters);
            int size= tokenizer.countTokens();
            String[] tokens= new String[size];
            for (int i = 0; i < size; i++)
                tokens[i] = tokenizer.nextToken();
            return tokens;
        }
    }
    
    private static final String TODO_TASK_TAGS= CCorePreferenceConstants.TODO_TASK_TAGS;    
    protected static final String TASK_TAG= ICColorConstants.TASK_TAG;

    private TaskTagRule fTaskTagRule;
    private Preferences fCorePreferenceStore;
    private String fDefaultTokenProperty;
    private String[] fTokenProperties;

    public CCommentScanner(IColorManager manager, IPreferenceStore store, String defaultTokenProperty) {
        this(manager, store, null, defaultTokenProperty, new String[] { defaultTokenProperty, TASK_TAG });
    }

    public CCommentScanner(IColorManager manager, IPreferenceStore store, Preferences coreStore, String defaultTokenProperty) {
        this(manager, store, coreStore, defaultTokenProperty, new String[] { defaultTokenProperty, TASK_TAG });
    }
    
    public CCommentScanner(IColorManager manager, IPreferenceStore store, Preferences coreStore, String defaultTokenProperty, String[] tokenProperties) {
        super(manager, store);
        
        fCorePreferenceStore= coreStore;
        fDefaultTokenProperty= defaultTokenProperty;
        fTokenProperties= tokenProperties;

        initialize();
    }

    /*
     * @see AbstractCScanner#createRules()
     */
    protected List createRules() {
        List list= new ArrayList();
        
        String tasks= null;
        if (getPreferenceStore().contains(TODO_TASK_TAGS)) {
            tasks= getPreferenceStore().getString(TODO_TASK_TAGS);
        } else if (fCorePreferenceStore != null) {
            tasks= fCorePreferenceStore.getString(TODO_TASK_TAGS);
        }
        
        if (tasks != null) {
            // Add rule for Task Tags.
            fTaskTagRule= new TaskTagRule(getToken(TASK_TAG));
            fTaskTagRule.addTaskTags(tasks);
            list.add(fTaskTagRule);
        }

        setDefaultReturnToken(getToken(fDefaultTokenProperty));

        return list;
    }

    /*
     * @see org.eclipse.cdt.internal.ui.text.AbstractJavaScanner#affectsBehavior(org.eclipse.jface.util.PropertyChangeEvent)
     */
    public boolean affectsBehavior(PropertyChangeEvent event) {
        return event.getProperty().equals(TODO_TASK_TAGS) || super.affectsBehavior(event);
    }

    /*
     * @see org.eclipse.cdt.internal.ui.text.AbstractJavaScanner#adaptToPreferenceChange(org.eclipse.jface.util.PropertyChangeEvent)
     */
    public void adaptToPreferenceChange(PropertyChangeEvent event) {
        if (fTaskTagRule != null && event.getProperty().equals(TODO_TASK_TAGS)) {
            Object value= event.getNewValue();

            if (value instanceof String) {
                fTaskTagRule.clearTaskTags();
                fTaskTagRule.addTaskTags((String) value);
            }
            
        } else if (super.affectsBehavior(event)) {
            super.adaptToPreferenceChange(event);
        }
    }

    /*
     * @see org.eclipse.cdt.internal.ui.text.AbstractJavaScanner#getTokenProperties()
     */
    protected String[] getTokenProperties() {
        return fTokenProperties;
    }

}

Lines 11-22 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/CSourceViewerConfiguration.java (-55 / +133 lines)
11	* Anton Leherbauer (Wind River Systems)	11	* Anton Leherbauer (Wind River Systems)
12	* Sergey Prigogin (Google)	12	* Sergey Prigogin (Google)
13	* Markus Schorn (Wind River Systems)	13	* Markus Schorn (Wind River Systems)
		14	* Andrew Ferguson (Symbian)
14	*******************************************************************************/	15	*******************************************************************************/
15	package org.eclipse.cdt.internal.ui.text;	16	package org.eclipse.cdt.internal.ui.text;
16		17
17	import java.util.Arrays;	18	import java.util.Arrays;
18		19
19	import org.eclipse.core.resources.IFile;	20	import org.eclipse.core.resources.IFile;
		21	import org.eclipse.core.resources.IProject;
		22	import org.eclipse.core.resources.IResource;
20	import org.eclipse.core.runtime.CoreException;	23	import org.eclipse.core.runtime.CoreException;
21	import org.eclipse.core.runtime.IPath;	24	import org.eclipse.core.runtime.IPath;
22	import org.eclipse.core.runtime.NullProgressMonitor;	25	import org.eclipse.core.runtime.NullProgressMonitor;
Lines 77-82 Link Here
77	import org.eclipse.cdt.ui.CUIPlugin;	80	import org.eclipse.cdt.ui.CUIPlugin;
78	import org.eclipse.cdt.ui.ILanguageUI;	81	import org.eclipse.cdt.ui.ILanguageUI;
79	import org.eclipse.cdt.ui.text.ICPartitions;	82	import org.eclipse.cdt.ui.text.ICPartitions;
		83	import org.eclipse.cdt.ui.text.ICTokenScanner;
		84	import org.eclipse.cdt.ui.text.ITokenStore;
		85	import org.eclipse.cdt.ui.text.ITokenStoreFactory;
		86	import org.eclipse.cdt.ui.text.doctools.DefaultMultilineCommentAutoEditStrategy;
		87	import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
		88	import org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration;
80		89
81	import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;	90	import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;
82		91
Lines 90-95 Link Here
90	import org.eclipse.cdt.internal.ui.text.contentassist.CContentAssistProcessor;	99	import org.eclipse.cdt.internal.ui.text.contentassist.CContentAssistProcessor;
91	import org.eclipse.cdt.internal.ui.text.contentassist.ContentAssistPreference;	100	import org.eclipse.cdt.internal.ui.text.contentassist.ContentAssistPreference;
92	import org.eclipse.cdt.internal.ui.text.correction.CCorrectionAssistant;	101	import org.eclipse.cdt.internal.ui.text.correction.CCorrectionAssistant;
		102	import org.eclipse.cdt.internal.ui.text.doctools.DocCommentOwnerManager;
93	import org.eclipse.cdt.internal.ui.typehierarchy.THInformationControl;	103	import org.eclipse.cdt.internal.ui.typehierarchy.THInformationControl;
94	import org.eclipse.cdt.internal.ui.typehierarchy.THInformationProvider;	104	import org.eclipse.cdt.internal.ui.typehierarchy.THInformationProvider;
95		105
Lines 111-121 Link Here
111	/**	121	/**
112	* The C multi-line comment scanner.	122	* The C multi-line comment scanner.
113	*/	123	*/
114	private AbstractCScanner fMultilineCommentScanner;	124	private ICTokenScanner fMultilineDocCommentScanner;
115	/**	125	/**
116	* The C single-line comment scanner.	126	* The C single-line comment scanner.
117	*/	127	*/
118	private AbstractCScanner fSinglelineCommentScanner;	128	private ICTokenScanner fSinglelineDocCommentScanner;
119	/**	129	/**
120	* The C string scanner.	130	* The C string scanner.
121	*/	131	*/
Lines 147-170 Link Here
147	}	157	}
148		158
149	/**	159	/**
150	* Returns the C multi-line comment scanner for this configuration.
151	*
152	* @return the C multi-line comment scanner
153	*/
154	protected RuleBasedScanner getMultilineCommentScanner() {
155	return fMultilineCommentScanner;
156	}
157
158	/**
159	* Returns the C single-line comment scanner for this configuration.
160	*
161	* @return the C single-line comment scanner
162	*/
163	protected RuleBasedScanner getSinglelineCommentScanner() {
164	return fSinglelineCommentScanner;
165	}
166
167	/**
168	* Returns the C string scanner for this configuration.	160	* Returns the C string scanner for this configuration.
169	*	161	*
170	* @return the C string scanner	162	* @return the C string scanner
Lines 184-193 Link Here
184	}	176	}
185	AbstractCScanner scanner= null;	177	AbstractCScanner scanner= null;
186	if (language instanceof ICLanguageKeywords) {	178	if (language instanceof ICLanguageKeywords) {
187	scanner= new CPreprocessorScanner(getColorManager(), fPreferenceStore, (ICLanguageKeywords)language);	179	scanner= new CPreprocessorScanner(getTokenStoreFactory(), (ICLanguageKeywords)language);
188	}	180	}
189	if (scanner == null) {	181	if (scanner == null) {
190	scanner= new CPreprocessorScanner(getColorManager(), fPreferenceStore, GPPLanguage.getDefault());	182	scanner= new CPreprocessorScanner(getTokenStoreFactory(), GPPLanguage.getDefault());
191	}	183	}
192	fPreprocessorScanner= scanner;	184	fPreprocessorScanner= scanner;
193	return fPreprocessorScanner;	185	return fPreprocessorScanner;
Lines 250-263 Link Here
250	presenter.setSizeConstraints(50, 20, true, false);	242	presenter.setSizeConstraints(50, 20, true, false);
251	return presenter;	243	return presenter;
252	}	244	}
253		245
254	/**	246	/**
255	* Initializes the scanners.	247	* Initializes the scanners.
256	*/	248	*/
257	private void initializeScanners() {	249	private void initializeScanners() {
258	fMultilineCommentScanner= new CCommentScanner(getColorManager(), fPreferenceStore, ICColorConstants.C_MULTI_LINE_COMMENT);	250	fStringScanner= new SingleTokenCScanner(getTokenStoreFactory(), ICColorConstants.C_STRING);
259	fSinglelineCommentScanner= new CCommentScanner(getColorManager(), fPreferenceStore, ICColorConstants.C_SINGLE_LINE_COMMENT);
260	fStringScanner= new SingleTokenCScanner(getColorManager(), fPreferenceStore, ICColorConstants.C_STRING);
261	}	251	}
262		252
263	/**	253	/**
Lines 274-290 Link Here
274		264
275	reconciler.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);	265	reconciler.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);
276	reconciler.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);	266	reconciler.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);
277
278	//TextAttribute attr = new TextAttribute(manager.getColor(ICColorConstants.C_DEFAULT));
279		267
280	dr= new DefaultDamagerRepairer(getSinglelineCommentScanner());	268	dr= new DefaultDamagerRepairer(new CCommentScanner(getTokenStoreFactory(), ICColorConstants.C_SINGLE_LINE_COMMENT));
281	reconciler.setDamager(dr, ICPartitions.C_SINGLE_LINE_COMMENT);	269	reconciler.setDamager(dr, ICPartitions.C_SINGLE_LINE_COMMENT);
282	reconciler.setRepairer(dr, ICPartitions.C_SINGLE_LINE_COMMENT);	270	reconciler.setRepairer(dr, ICPartitions.C_SINGLE_LINE_COMMENT);
283		271
284	dr= new DefaultDamagerRepairer(getMultilineCommentScanner());	272	dr= new DefaultDamagerRepairer(new CCommentScanner(getTokenStoreFactory(), ICColorConstants.C_MULTI_LINE_COMMENT));
285	reconciler.setDamager(dr, ICPartitions.C_MULTI_LINE_COMMENT);	273	reconciler.setDamager(dr, ICPartitions.C_MULTI_LINE_COMMENT);
286	reconciler.setRepairer(dr, ICPartitions.C_MULTI_LINE_COMMENT);	274	reconciler.setRepairer(dr, ICPartitions.C_MULTI_LINE_COMMENT);
287		275
		276	ICTokenScanner docCommentSingleScanner= getSinglelineDocCommentScanner(getProject());
		277	if(docCommentSingleScanner!=null) {
		278	dr= new DefaultDamagerRepairer(docCommentSingleScanner);
		279	reconciler.setDamager(dr, ICPartitions.C_SINGLE_LINE_DOC_COMMENT);
		280	reconciler.setRepairer(dr, ICPartitions.C_SINGLE_LINE_DOC_COMMENT);
		281	}
		282
		283	ICTokenScanner docCommentMultiScanner= getMultilineDocCommentScanner(getProject());
		284	if(docCommentMultiScanner!=null) {
		285	dr= new DefaultDamagerRepairer(docCommentMultiScanner);
		286	reconciler.setDamager(dr, ICPartitions.C_MULTI_LINE_DOC_COMMENT);
		287	reconciler.setRepairer(dr, ICPartitions.C_MULTI_LINE_DOC_COMMENT);
		288	}
		289
288	dr= new DefaultDamagerRepairer(getStringScanner());	290	dr= new DefaultDamagerRepairer(getStringScanner());
289	reconciler.setDamager(dr, ICPartitions.C_STRING);	291	reconciler.setDamager(dr, ICPartitions.C_STRING);
290	reconciler.setRepairer(dr, ICPartitions.C_STRING);	292	reconciler.setRepairer(dr, ICPartitions.C_STRING);
Lines 299-306 Link Here
299		301
300	return reconciler;	302	return reconciler;
301	}	303	}
		304
		305	/**
		306	* Returns the C multi-line comment scanner for this configuration.
		307	*
		308	* @return the C multi-line comment scanner
		309	*/
		310	protected ICTokenScanner getMultilineDocCommentScanner(IResource resource) {
		311	if (fMultilineDocCommentScanner == null) {
		312	IDocCommentViewerConfiguration owner= DocCommentOwnerManager.getInstance().getCommentOwner(resource).getMultilineConfiguration();
		313	fMultilineDocCommentScanner= owner.createCommentScanner(getTokenStoreFactory());
		314	}
		315	return fMultilineDocCommentScanner;
		316	}
302		317
303	/**	318	/**
		319	* Returns the C single-line comment scanner for this configuration.
		320	*
		321	* @return the C single-line comment scanner
		322	*/
		323	protected ICTokenScanner getSinglelineDocCommentScanner(IResource resource) {
		324	if (fSinglelineDocCommentScanner == null) {
		325	IDocCommentViewerConfiguration owner= DocCommentOwnerManager.getInstance().getCommentOwner(resource).getSinglelineConfiguration();
		326	fSinglelineDocCommentScanner= owner.createCommentScanner(getTokenStoreFactory());
		327	}
		328	return fSinglelineDocCommentScanner;
		329	}
		330
		331	/**
304	* @return the code scanner for the given language	332	* @return the code scanner for the given language
305	*/	333	*/
306	protected RuleBasedScanner getCodeScanner(ILanguage language) {	334	protected RuleBasedScanner getCodeScanner(ILanguage language) {
Lines 310-323 Link Here
310	RuleBasedScanner scanner= null;	338	RuleBasedScanner scanner= null;
311	if (language instanceof ICLanguageKeywords) {	339	if (language instanceof ICLanguageKeywords) {
312	ICLanguageKeywords cLang= (ICLanguageKeywords)language;	340	ICLanguageKeywords cLang= (ICLanguageKeywords)language;
313	scanner = new CCodeScanner(getColorManager(), fPreferenceStore, cLang);	341	scanner = new CCodeScanner(getTokenStoreFactory(), cLang);
314	} else if (language != null) {	342	} else if (language != null) {
315	ILanguageUI languageUI = (ILanguageUI)language.getAdapter(ILanguageUI.class);	343	ILanguageUI languageUI = (ILanguageUI)language.getAdapter(ILanguageUI.class);
316	if (languageUI != null)	344	if (languageUI != null)
317	scanner = languageUI.getCodeScanner();	345	scanner = languageUI.getCodeScanner();
318	}	346	}
319	if (scanner == null) {	347	if (scanner == null) {
320	scanner = new CCodeScanner(getColorManager(), fPreferenceStore, GPPLanguage.getDefault());	348	scanner = new CCodeScanner(getTokenStoreFactory(), GPPLanguage.getDefault());
321	}	349	}
322	if (scanner instanceof AbstractCScanner) {	350	if (scanner instanceof AbstractCScanner) {
323	fCodeScanner= (AbstractCScanner)scanner;	351	fCodeScanner= (AbstractCScanner)scanner;
Lines 347-352 Link Here
347	processor = new CContentAssistProcessor(getEditor(), sourceViewer, assistant, ICPartitions.C_SINGLE_LINE_COMMENT);	375	processor = new CContentAssistProcessor(getEditor(), sourceViewer, assistant, ICPartitions.C_SINGLE_LINE_COMMENT);
348	assistant.setContentAssistProcessor(processor, ICPartitions.C_SINGLE_LINE_COMMENT);	376	assistant.setContentAssistProcessor(processor, ICPartitions.C_SINGLE_LINE_COMMENT);
349		377
		378	processor = new CContentAssistProcessor(getEditor(), sourceViewer, assistant, ICPartitions.C_MULTI_LINE_DOC_COMMENT);
		379	assistant.setContentAssistProcessor(processor, ICPartitions.C_MULTI_LINE_DOC_COMMENT);
		380
		381	processor = new CContentAssistProcessor(getEditor(), sourceViewer, assistant, ICPartitions.C_SINGLE_LINE_DOC_COMMENT);
		382	assistant.setContentAssistProcessor(processor, ICPartitions.C_SINGLE_LINE_DOC_COMMENT);
		383
350	processor = new CContentAssistProcessor(getEditor(), sourceViewer, assistant, ICPartitions.C_STRING);	384	processor = new CContentAssistProcessor(getEditor(), sourceViewer, assistant, ICPartitions.C_STRING);
351	assistant.setContentAssistProcessor(processor, ICPartitions.C_STRING);	385	assistant.setContentAssistProcessor(processor, ICPartitions.C_STRING);
352		386
Lines 410-435 Link Here
410	*/	444	*/
411	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {	445	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {
412	String partitioning= getConfiguredDocumentPartitioning(sourceViewer);	446	String partitioning= getConfiguredDocumentPartitioning(sourceViewer);
		447
		448	IDocCommentOwner owner= DocCommentOwnerManager.getInstance().getCommentOwner(getProject());
		449	IAutoEditStrategy single= owner.getSinglelineConfiguration().createAutoEditStrategy();
		450	IAutoEditStrategy multi= owner.getMultilineConfiguration().createAutoEditStrategy();
		451
		452	IAutoEditStrategy[] NONE= new IAutoEditStrategy[0];
		453
413	if (ICPartitions.C_MULTI_LINE_COMMENT.equals(contentType))	454	if (ICPartitions.C_MULTI_LINE_COMMENT.equals(contentType))
414	return new IAutoEditStrategy[] { new CCommentAutoIndentStrategy() };	455	return new IAutoEditStrategy[] { new DefaultMultilineCommentAutoEditStrategy() };
		456	if (ICPartitions.C_SINGLE_LINE_DOC_COMMENT.equals(contentType))
		457	return single!=null ? new IAutoEditStrategy[] {single} : NONE;
		458	else if (ICPartitions.C_MULTI_LINE_DOC_COMMENT.equals(contentType))
		459	return multi!=null? new IAutoEditStrategy[] {multi} : NONE;
415	else if (ICPartitions.C_STRING.equals(contentType))	460	else if (ICPartitions.C_STRING.equals(contentType))
416	return new IAutoEditStrategy[] { /new SmartSemicolonAutoEditStrategy(partitioning),/ new CStringAutoIndentStrategy(partitioning, getProject()) };	461	return new IAutoEditStrategy[] { /new SmartSemicolonAutoEditStrategy(partitioning),/ new CStringAutoIndentStrategy(partitioning, getCProject()) };
417	else	462	else
418	return new IAutoEditStrategy[] { new CAutoIndentStrategy(partitioning, getProject()) };	463	return new IAutoEditStrategy[] { new CAutoIndentStrategy(partitioning, getCProject()) };
419	}	464	}
420		465
421	/**	466	/**
422	* @see SourceViewerConfiguration#getDoubleClickStrategy(ISourceViewer, String)	467	* @see SourceViewerConfiguration#getDoubleClickStrategy(ISourceViewer, String)
423	*/	468	*/
424	public ITextDoubleClickStrategy getDoubleClickStrategy(ISourceViewer sourceViewer, String contentType) {	469	public ITextDoubleClickStrategy getDoubleClickStrategy(ISourceViewer sourceViewer, String contentType) {
425	if (ICPartitions.C_MULTI_LINE_COMMENT.equals(contentType) \|\|	470	if (ICPartitions.C_MULTI_LINE_COMMENT.equals(contentType) \|\|
426	ICPartitions.C_SINGLE_LINE_COMMENT.equals(contentType))	471	ICPartitions.C_SINGLE_LINE_COMMENT.equals(contentType)) {
427	return new DefaultTextDoubleClickStrategy();	472	return new DefaultTextDoubleClickStrategy();
428	else if (ICPartitions.C_STRING.equals(contentType) \|\|	473	} else if (ICPartitions.C_SINGLE_LINE_DOC_COMMENT.equals(contentType)) {
429	ICPartitions.C_CHARACTER.equals(contentType))	474	IDocCommentOwner owner= DocCommentOwnerManager.getInstance().getCommentOwner(getProject());
		475	ITextDoubleClickStrategy single= owner.getSinglelineConfiguration().createDoubleClickStrategy();
		476	return single != null ? single : new DefaultTextDoubleClickStrategy();
		477	} else if(ICPartitions.C_MULTI_LINE_DOC_COMMENT.equals(contentType)) {
		478	IDocCommentOwner owner= DocCommentOwnerManager.getInstance().getCommentOwner(getProject());
		479	ITextDoubleClickStrategy multi= owner.getMultilineConfiguration().createDoubleClickStrategy();
		480	return multi!=null ? multi : new DefaultTextDoubleClickStrategy();
		481	} else if (ICPartitions.C_STRING.equals(contentType) \|\|
		482	ICPartitions.C_CHARACTER.equals(contentType)) {
430	return new CStringDoubleClickSelector(getConfiguredDocumentPartitioning(sourceViewer));	483	return new CStringDoubleClickSelector(getConfiguredDocumentPartitioning(sourceViewer));
431	else if (ICPartitions.C_PREPROCESSOR.equals(contentType))	484	} else if (ICPartitions.C_PREPROCESSOR.equals(contentType)) {
432	return new CStringDoubleClickSelector(getConfiguredDocumentPartitioning(sourceViewer), new CDoubleClickSelector());	485	return new CStringDoubleClickSelector(getConfiguredDocumentPartitioning(sourceViewer), new CDoubleClickSelector());
		486	}
433	return new CDoubleClickSelector();	487	return new CDoubleClickSelector();
434	}	488	}
435		489
Lines 444-450 Link Here
444	* @see SourceViewerConfiguration#getIndentPrefixes(ISourceViewer, String)	498	* @see SourceViewerConfiguration#getIndentPrefixes(ISourceViewer, String)
445	*/	499	*/
446	public String[] getIndentPrefixes(ISourceViewer sourceViewer, String contentType) {	500	public String[] getIndentPrefixes(ISourceViewer sourceViewer, String contentType) {
447	ICProject project= getProject();	501	ICProject project= getCProject();
448	final int tabWidth= CodeFormatterUtil.getTabWidth(project);	502	final int tabWidth= CodeFormatterUtil.getTabWidth(project);
449	final int indentWidth= CodeFormatterUtil.getIndentWidth(project);	503	final int indentWidth= CodeFormatterUtil.getIndentWidth(project);
450	boolean allowTabs= tabWidth <= indentWidth;	504	boolean allowTabs= tabWidth <= indentWidth;
Lines 504-510 Link Here
504	return new String(spaceChars);	558	return new String(spaceChars);
505	}	559	}
506		560
507	private ICProject getProject() {	561	/**
		562	* Returns the ICProject associated with this CSourceViewerConfiguration, or null if
		563	* no ICProject could be determined
		564	* @return
		565	*/
		566	private ICProject getCProject() {
508	ITextEditor editor= getEditor();	567	ITextEditor editor= getEditor();
509	if (editor == null)	568	if (editor == null)
510	return null;	569	return null;
Lines 527-533 Link Here
527	* @see SourceViewerConfiguration#getTabWidth(ISourceViewer)	586	* @see SourceViewerConfiguration#getTabWidth(ISourceViewer)
528	*/	587	*/
529	public int getTabWidth(ISourceViewer sourceViewer) {	588	public int getTabWidth(ISourceViewer sourceViewer) {
530	return CodeFormatterUtil.getTabWidth(getProject());	589	return CodeFormatterUtil.getTabWidth(getCProject());
531	}	590	}
532		591
533	/**	592	/**
Lines 603-609 Link Here
603	ICPartitions.C_SINGLE_LINE_COMMENT,	662	ICPartitions.C_SINGLE_LINE_COMMENT,
604	ICPartitions.C_STRING,	663	ICPartitions.C_STRING,
605	ICPartitions.C_CHARACTER,	664	ICPartitions.C_CHARACTER,
606	ICPartitions.C_PREPROCESSOR};	665	ICPartitions.C_PREPROCESSOR,
		666	ICPartitions.C_SINGLE_LINE_DOC_COMMENT,
		667	ICPartitions.C_MULTI_LINE_DOC_COMMENT
		668	};
607	}	669	}
608		670
609	/**	671	/**
Lines 620-627 Link Here
620	}	682	}
621		683
622	public boolean affectsBehavior(PropertyChangeEvent event) {	684	public boolean affectsBehavior(PropertyChangeEvent event) {
623	if (fMultilineCommentScanner.affectsBehavior(event)	685	if ((fMultilineDocCommentScanner != null && fMultilineDocCommentScanner.affectsBehavior(event))
624	\|\| fSinglelineCommentScanner.affectsBehavior(event)	686	\|\| (fSinglelineDocCommentScanner != null && fSinglelineDocCommentScanner.affectsBehavior(event))
625	\|\| fStringScanner.affectsBehavior(event)) {	687	\|\| fStringScanner.affectsBehavior(event)) {
626	return true;	688	return true;
627	}	689	}
Lines 714-723 Link Here
714	public void handlePropertyChangeEvent(PropertyChangeEvent event) {	776	public void handlePropertyChangeEvent(PropertyChangeEvent event) {
715	if (fCodeScanner != null && fCodeScanner.affectsBehavior(event))	777	if (fCodeScanner != null && fCodeScanner.affectsBehavior(event))
716	fCodeScanner.adaptToPreferenceChange(event);	778	fCodeScanner.adaptToPreferenceChange(event);
717	if (fMultilineCommentScanner.affectsBehavior(event))	779	if (fMultilineDocCommentScanner!=null && fMultilineDocCommentScanner.affectsBehavior(event))
718	fMultilineCommentScanner.adaptToPreferenceChange(event);	780	fMultilineDocCommentScanner.adaptToPreferenceChange(event);
719	if (fSinglelineCommentScanner.affectsBehavior(event))	781	if (fSinglelineDocCommentScanner!=null && fSinglelineDocCommentScanner.affectsBehavior(event))
720	fSinglelineCommentScanner.adaptToPreferenceChange(event);	782	fSinglelineDocCommentScanner.adaptToPreferenceChange(event);
721	if (fStringScanner.affectsBehavior(event))	783	if (fStringScanner.affectsBehavior(event))
722	fStringScanner.adaptToPreferenceChange(event);	784	fStringScanner.adaptToPreferenceChange(event);
723	if (fPreprocessorScanner != null && fPreprocessorScanner.affectsBehavior(event))	785	if (fPreprocessorScanner != null && fPreprocessorScanner.affectsBehavior(event))
Lines 833-841 Link Here
833	*/	895	*/
834	public void resetScanners() {	896	public void resetScanners() {
835	fCodeScanner= null;	897	fCodeScanner= null;
		898	fMultilineDocCommentScanner= null;
		899	fSinglelineDocCommentScanner= null;
836	fPreprocessorScanner= null;	900	fPreprocessorScanner= null;
837	}	901	}
838		902
839	/**	903	/**
840	* Creates macro exploration presenter.	904	* Creates macro exploration presenter.
841	* @param sourceViewer	905	* @param sourceViewer
Lines 873-878 Link Here
873	};	937	};
874	return conrolCreator;	938	return conrolCreator;
875	}	939	}
		940
		941	private IProject getProject() {
		942	ICProject cproject= getCProject();
		943	if(cproject!=null) {
		944	return cproject.getProject();
		945	}
		946	return null;
		947	}
876		948
877		949	private ITokenStoreFactory getTokenStoreFactory() {
878	}	950	return new ITokenStoreFactory() {
		951	public ITokenStore createTokenStore(String[] propertyColorNames) {
		952	return new TokenStore(getColorManager(), fPreferenceStore, propertyColorNames);
		953	}
		954	};
		955	}
		956	}




 *
 * Contributors:
 *     Anton Leherbauer (Wind River Systems) - initial API and implementation
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

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

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.PatternRule;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.jface.text.rules.WhitespaceRule;
import org.eclipse.jface.text.rules.WordRule;

import org.eclipse.cdt.core.model.ICLanguageKeywords;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;

import org.eclipse.cdt.internal.ui.text.util.CWhitespaceDetector;
import org.eclipse.cdt.internal.ui.text.util.CWordDetector;

	
	/**
	 * Creates a C/C++ preprocessor scanner.
	 * 
     * @param manager the color manager
     * @param store  the preference store
     * @param keywords  the keywords defined by the language dialect
	 */
	public CPreprocessorScanner(ITokenStoreFactory factory, ICLanguageKeywords keywords) {
		super(factory.createTokenStore(fgTokenProperties));
		fKeywords= keywords;
		setRules(createRules());
	}

	/*

	 */
	protected List createRules() {

		IToken defaultToken= getToken(ICColorConstants.PP_DEFAULT);

		List rules= new ArrayList();		
		IToken token;
		
		// Add generic white space rule.
		rules.add(new WhitespaceRule(new CWhitespaceDetector()));

        setDefaultReturnToken(defaultToken);
		return rules;
	}

	/*
	 * @see org.eclipse.cdt.internal.ui.text.AbstractCScanner#getTokenProperties()
	 */
	protected String[] getTokenProperties() {
		return fgTokenProperties;
	}

}




 * Auto indent strategy sensitive to brackets.
 */
public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
	private static final String MULTILINE_COMMENT_CLOSE = "*/"; //$NON-NLS-1$
	/** The line comment introducer. Value is "{@value}" */
	private static final String LINE_COMMENT= "//"; //$NON-NLS-1$
//	private static final GCCScannerExtensionConfiguration C_GNU_SCANNER_EXTENSION = new GCCScannerExtensionConfiguration();

			super.customizeDocumentCommand(d, c);
			return;
		}
		
		/*
         * I removed the workaround for 48339 as I believe the recent changes to 
         * FastCPartitioner are enough to fix this.
         */
		boolean isNewLine= c.length == 0 && c.text != null && isLineDelimiter(d, c.text);
		if (isNewLine) {
			smartIndentAfterNewLine(d, c);
		} else if ("/".equals(c.text) && isAppendToOpenMultilineComment(d, c)) { //$NON-NLS-1$
			// special case: multi-line comment at end of document (bug 48339)
			CCommentAutoIndentStrategy.commentIndentForCommentEnd(d, c);
		} else if (c.text.length() == 1) {
			smartIndentOnKeypress(d, c);
		} else if (c.text.length() > 1 && getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_PASTE)) {
			smartPaste(d, c); // no smart backspace for paste
		}
	}
	
	/**
	 * Check, if the command appends to an open multi-line comment.
	 * @param d  the document
	 * @param c  the document command
	 * @return true, if the command appends to an open multi-line comment.
	 */
	private boolean isAppendToOpenMultilineComment(IDocument d, DocumentCommand c) {
		if (d.getLength() >= 2 && c.offset == d.getLength()) {
			try {
				String contentType = TextUtilities.getContentType(d, fPartitioning, c.offset - 1, false);
				if (ICPartitions.C_MULTI_LINE_COMMENT.equals(contentType)) {
					return !d.get(c.offset - 2, 2).equals(MULTILINE_COMMENT_CLOSE);
				}
			} catch (BadLocationException exc) {
				// see below
			}
		}
		return false;
	}

	private static IPreferenceStore getPreferenceStore() {
		return CUIPlugin.getDefault().getCombinedPreferenceStore();

Lines 21-26 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/FastCPartitionScanner.java (-11 / +61 lines)
21	import org.eclipse.jface.text.rules.Token;	21	import org.eclipse.jface.text.rules.Token;
22		22
23	import org.eclipse.cdt.ui.text.ICPartitions;	23	import org.eclipse.cdt.ui.text.ICPartitions;
		24	import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
24		25
25		26
26	/**	27	/**
Lines 38-43 Link Here
38	private static final int PREPROCESSOR= 5;	39	private static final int PREPROCESSOR= 5;
39	private static final int PREPROCESSOR_MULTI_LINE_COMMENT= 6;	40	private static final int PREPROCESSOR_MULTI_LINE_COMMENT= 6;
40	private static final int PREPROCESSOR_STRING= 7;	41	private static final int PREPROCESSOR_STRING= 7;
		42	private static final int SINGLE_LINE_DOC_COMMENT= 8;
		43	private static final int MULTI_LINE_DOC_COMMENT= 9;
41		44
42	// beginning of prefixes and postfixes	45	// beginning of prefixes and postfixes
43	private static final int NONE= 0;	46	private static final int NONE= 0;
Lines 65-75 Link Here
65	private int fPrefixLength;	68	private int fPrefixLength;
66	/** Indicate whether current char is first non-whitespace char on the line*/	69	/** Indicate whether current char is first non-whitespace char on the line*/
67	private boolean fFirstCharOnLine= true;	70	private boolean fFirstCharOnLine= true;
68		71	/ An optional (possibly null) comment owner for detecting documentation-comments /
		72	private IDocCommentOwner fOwner;
		73
69	// emulate CPartitionScanner	74	// emulate CPartitionScanner
70	private final boolean fEmulate;	75	private final boolean fEmulate;
71	private int fCCodeOffset;	76	private int fCCodeOffset;
72	private int fCCodeLength;	77	private int fCCodeLength;
		78	private IDocument fDocument;
73		79
74	private final IToken[] fTokens= new IToken[] {	80	private final IToken[] fTokens= new IToken[] {
75	new Token(null),	81	new Token(null),
Lines 80-93 Link Here
80	new Token(C_PREPROCESSOR),	86	new Token(C_PREPROCESSOR),
81	new Token(C_MULTI_LINE_COMMENT),	87	new Token(C_MULTI_LINE_COMMENT),
82	new Token(C_PREPROCESSOR),	88	new Token(C_PREPROCESSOR),
		89	new Token(C_SINGLE_LINE_DOC_COMMENT),
		90	new Token(C_MULTI_LINE_DOC_COMMENT)
83	};	91	};
84		92
85	public FastCPartitionScanner(boolean emulate) {	93	public FastCPartitionScanner(boolean emulate, IDocCommentOwner owner) {
86	fEmulate= emulate;	94	fEmulate= emulate;
		95	fOwner= owner;
87	}	96	}
88		97
		98	public FastCPartitionScanner(IDocCommentOwner owner) {
		99	this(false, owner);
		100	}
		101
89	public FastCPartitionScanner() {	102	public FastCPartitionScanner() {
90	this(false);	103	this(false, null);
91	}	104	}
92		105
93	/*	106	/*
Lines 533-546 Link Here
533	}	546	}
534		547
535	private final IToken postFix(int state) {	548	private final IToken postFix(int state) {
		549	return postFix(state, CCODE);
		550	}
		551
		552	private final IToken postFix(int state, int newState) {
536	fTokenLength++;	553	fTokenLength++;
537	fLast= NONE;	554	fLast= NONE;
538	fState= CCODE;	555	fState= newState;
539	fPrefixLength= 0;	556	fPrefixLength= 0;
540	return fTokens[state];	557	return fTokens[interceptTokenState(state)];
541	}	558	}
542		559
		560
543	private final IToken preFix(int state, int newState, int last, int prefixLength) {	561	private final IToken preFix(int state, int newState, int last, int prefixLength) {
		562
544	// emulate CPartitionScanner	563	// emulate CPartitionScanner
545	if (fEmulate && state == CCODE && (fTokenLength - getLastLength(fLast) > 0)) {	564	if (fEmulate && state == CCODE && (fTokenLength - getLastLength(fLast) > 0)) {
546	fTokenLength -= getLastLength(fLast);	565	fTokenLength -= getLastLength(fLast);
Lines 550-564 Link Here
550	fState= newState;	569	fState= newState;
551	fPrefixLength= prefixLength;	570	fPrefixLength= prefixLength;
552	fLast= last;	571	fLast= last;
553	return fTokens[state];	572	return fTokens[interceptTokenState(state)];
554		573
555	} else {	574	} else {
556	fTokenLength -= getLastLength(fLast);	575	fTokenLength -= getLastLength(fLast);
557	fLast= last;	576	fLast= last;
558	fPrefixLength= prefixLength;	577	fPrefixLength= prefixLength;
559	IToken token= fTokens[state];
560	fState= newState;	578	fState= newState;
561	return token;	579	return fTokens[interceptTokenState(state)];
562	}	580	}
563	}	581	}
564		582
Lines 581-587 Link Here
581		599
582	else if (contentType.equals(C_PREPROCESSOR))	600	else if (contentType.equals(C_PREPROCESSOR))
583	return PREPROCESSOR;	601	return PREPROCESSOR;
584		602
		603	else if (contentType.equals(C_SINGLE_LINE_DOC_COMMENT))
		604	return SINGLE_LINE_COMMENT; // intentionally non-doc state: the state machine is doc-comment unaware
		605
		606	else if (contentType.equals(C_MULTI_LINE_DOC_COMMENT))
		607	return MULTI_LINE_COMMENT; // intentionally non-doc state: the state machine is doc-comment unaware
		608
585	else	609	else
586	return CCODE;	610	return CCODE;
587	}	611	}
Lines 590-596 Link Here
590	* @see IPartitionTokenScanner#setPartialRange(IDocument, int, int, String, int)	614	* @see IPartitionTokenScanner#setPartialRange(IDocument, int, int, String, int)
591	*/	615	*/
592	public void setPartialRange(IDocument document, int offset, int length, String contentType, int partitionOffset) {	616	public void setPartialRange(IDocument document, int offset, int length, String contentType, int partitionOffset) {
593		617	fDocument= document;
594	fScanner.setRange(document, offset, length);	618	fScanner.setRange(document, offset, length);
595	fTokenOffset= partitionOffset;	619	fTokenOffset= partitionOffset;
596	fTokenLength= 0;	620	fTokenLength= 0;
Lines 622-628 Link Here
622	* @see ITokenScanner#setRange(IDocument, int, int)	646	* @see ITokenScanner#setRange(IDocument, int, int)
623	*/	647	*/
624	public void setRange(IDocument document, int offset, int length) {	648	public void setRange(IDocument document, int offset, int length) {
625		649	fDocument= document;
626	fScanner.setRange(document, offset, length);	650	fScanner.setRange(document, offset, length);
627	fTokenOffset= offset;	651	fTokenOffset= offset;
628	fTokenLength= 0;	652	fTokenLength= 0;
Lines 658-661 Link Here
658	return fTokenOffset;	682	return fTokenOffset;
659	}	683	}
660		684
		685	private int interceptTokenState(int proposedTokenState) {
		686	if(fOwner!=null) {
		687	switch(proposedTokenState) {
		688	case MULTI_LINE_COMMENT:
		689	if(fOwner.getMultilineConfiguration().isDocumentationComment(fDocument, fTokenOffset, fTokenLength))
		690	return MULTI_LINE_DOC_COMMENT;
		691	break;
		692
		693	case SINGLE_LINE_COMMENT:
		694	if(fOwner.getSinglelineConfiguration().isDocumentationComment(fDocument, fTokenOffset, fTokenLength))
		695	return SINGLE_LINE_DOC_COMMENT;
		696	break;
		697
		698	}
		699	}
		700	return proposedTokenState;
		701	}
		702
		703	/**
		704	* @return the DocCommentOwner associated with this partition scanner, or null
		705	* if there is no owner.
		706	* @since 5.0
		707	*/
		708	public IDocCommentOwner getDocCommentOwner() {
		709	return fOwner;
		710	}
661	}	711	}

Lines 16-21 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/FastCPartitioner.java (+21 lines)
16	import org.eclipse.jface.text.rules.IPartitionTokenScanner;	16	import org.eclipse.jface.text.rules.IPartitionTokenScanner;
17		17
18	import org.eclipse.cdt.ui.text.ICPartitions;	18	import org.eclipse.cdt.ui.text.ICPartitions;
		19	import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
19		20
20	/**	21	/**
21	* A slightly adapted FastPartitioner.	22	* A slightly adapted FastPartitioner.
Lines 44-53 Link Here
44	if (fDocument.getChar(offset - 1) != '\n') {	45	if (fDocument.getChar(offset - 1) != '\n') {
45	return region;	46	return region;
46	}	47	}
		48	} else if (ICPartitions.C_MULTI_LINE_DOC_COMMENT.equals(region.getType())) {
		49	if (!fDocument.get(offset - 2, 2).equals("*/")) { //$NON-NLS-1$
		50	return region;
		51	}
		52	} else if (ICPartitions.C_SINGLE_LINE_DOC_COMMENT.equals(region .getType())) {
		53	if (fDocument.getChar(offset - 1) != '\n') {
		54	return region;
		55	}
47	}	56	}
48	} catch (BadLocationException exc) {	57	} catch (BadLocationException exc) {
49	}	58	}
50	}	59	}
51	return super.getPartition(offset, preferOpenPartitions);	60	return super.getPartition(offset, preferOpenPartitions);
52	}	61	}
		62
		63	/**
		64	* @return the DocCommentOwner associated with this partition scanner, or null
		65	* if there is no owner.
		66	* @since 5.0
		67	*/
		68	public IDocCommentOwner getDocCommentOwner() {
		69	if(fScanner instanceof FastCPartitionScanner) {
		70	return ((FastCPartitionScanner)fScanner).getDocCommentOwner();
		71	}
		72	return null;
		73	}
53	}	74	}




/*******************************************************************************
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 * 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

 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     QNX Software System
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.resource.StringConverter;
import org.eclipse.jface.text.TextAttribute;
import org.eclipse.jface.text.rules.BufferedRuleBasedScanner;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Display;

import org.eclipse.cdt.ui.PreferenceConstants;

import org.eclipse.cdt.ui.IPropertyChangeParticipant;
import org.eclipse.cdt.ui.text.ICTokenScanner;
import org.eclipse.cdt.ui.text.ITokenStore;

/**
 * Convenience implementation.
 * only responsible for providing a list of preference keys for based on which tokens
 * are generated and to use this tokens to define the rules controlling this scanner.
 * <p>
 * This scanner stores the color defined by the color preference key into
 * the color manager under the same key.
 * </p>
 * <p>
 * Preference color key + {@link PreferenceConstants#EDITOR_BOLD_SUFFIX} are used
 * to retrieve whether the token is rendered in bold.
 * </p>
 * <p>
 * Preference color key + {@link PreferenceConstants#EDITOR_ITALIC_SUFFIX} are used
 * to retrieve whether the token is rendered in italic.
 * </p>
 * <p>
 * Preference color key + {@link PreferenceConstants#EDITOR_STRIKETHROUGH_SUFFIX} are used
 * to retrieve whether the token is rendered in strikethrough.
 * </p>
 * <p>
 * Preference color key + {@link PreferenceConstants#EDITOR_UNDERLINE_SUFFIX} are used
 * to retrieve whether the token is rendered in underline.
 * </p>
 */
public abstract class AbstractCScanner extends BufferedRuleBasedScanner implements ICTokenScanner {
	private List/*<IPropertyChangeParticipant*/ pcps;
	final protected ITokenStore fTokenStore;
	private IColorManager fColorManager;
	private IPreferenceStore fPreferenceStore;

	private Map fTokenMap= new HashMap();
	private String[] fPropertyNamesColor;
	/**
	 * Preference keys for boolean preferences which are <code>true</code>,
	 * iff the corresponding token should be rendered bold.
	 */
	private String[] fPropertyNamesBold;
	/**
	 * Preference keys for boolean preferences which are <code>true</code>,
	 * iff the corresponding token should be rendered italic.
	 *
	 * @since 4.0
	 */
	private String[] fPropertyNamesItalic;
	/**
	 * Preference keys for boolean preferences which are <code>true</code>,
	 * iff the corresponding token should be rendered strikethrough.
	 *
	 * @since 4.0
	 */
	private String[] fPropertyNamesStrikethrough;
	/**
	 * Preference keys for boolean preferences which are <code>true</code>,
	 * iff the corresponding token should be rendered underline.
	 *
	 * @since 4.0
	 */
	private String[] fPropertyNamesUnderline;


	private boolean fNeedsLazyColorLoading;

	/**
	 * Returns an array of preference keys which define the tokens
	 * used in the rules of this scanner.
	 * <p>
	 * The preference key is used access the color in the preference
	 * store and in the color manager.
	 * </p>
	 * <p>
	 * Preference key + {@link PreferenceConstants#EDITOR_BOLD_SUFFIX} is used
	 * to retrieve whether the token is rendered in bold.
	 * </p>
	 * <p>
	 * Preference key + {@link PreferenceConstants#EDITOR_ITALIC_SUFFIX} is used
	 * to retrieve whether the token is rendered in italic.
	 * </p>
	 * <p>
	 * Preference key + {@link PreferenceConstants#EDITOR_UNDERLINE_SUFFIX} is used
	 * to retrieve whether the token is rendered underlined.
	 * </p>
	 * <p>
	 * Preference key + {@link PreferenceConstants#EDITOR_STRIKETHROUGH_SUFFIX} is used
	 * to retrieve whether the token is rendered stricken out.
	 * </p>
	 */
	abstract protected String[] getTokenProperties();

	/**
	 * Creates the list of rules controlling this scanner.
	 */
	abstract protected List createRules();


	/**
	 * Creates an abstract C scanner.
	 */
	public AbstractCScanner(IColorManager manager, IPreferenceStore store) {
		super();
		fColorManager= manager;
		fPreferenceStore= store;
	}

	/**
	 * Creates an abstract C scanner.
	 */
	public AbstractCScanner(IColorManager manager, IPreferenceStore store, int bufsize) {
		super(bufsize);
		fColorManager= manager;
		fPreferenceStore= store;
	}

	/**
	 * Must be called after the constructor has been called.
	 */
	public final void initialize() {

		fPropertyNamesColor= getTokenProperties();
		int length= fPropertyNamesColor.length;
		fPropertyNamesBold= new String[length];
		fPropertyNamesItalic= new String[length];
		fPropertyNamesStrikethrough= new String[length];
		fPropertyNamesUnderline= new String[length];

		for (int i= 0; i < length; i++) {
			fPropertyNamesBold[i]= getBoldKey(fPropertyNamesColor[i]);
			fPropertyNamesItalic[i]= getItalicKey(fPropertyNamesColor[i]);
			fPropertyNamesStrikethrough[i]= getStrikethroughKey(fPropertyNamesColor[i]);
			fPropertyNamesUnderline[i]= getUnderlineKey(fPropertyNamesColor[i]);
		}
		
		fNeedsLazyColorLoading= Display.getCurrent() == null;
		for (int i= 0; i < length; i++) {
			if (fNeedsLazyColorLoading)
				addTokenWithProxyAttribute(fPropertyNamesColor[i], fPropertyNamesBold[i], fPropertyNamesItalic[i], fPropertyNamesStrikethrough[i], fPropertyNamesUnderline[i]);
			else
				addToken(fPropertyNamesColor[i], fPropertyNamesBold[i], fPropertyNamesItalic[i], fPropertyNamesStrikethrough[i], fPropertyNamesUnderline[i]);
		}

		initializeRules();
	}
	
	public AbstractCScanner(ITokenStore tokenStore, int size) {
		this(tokenStore);
		setBufferSize(size);

	protected String getItalicKey(String colorKey) {
		return colorKey + PreferenceConstants.EDITOR_ITALIC_SUFFIX;
	}
	
	public AbstractCScanner(ITokenStore tokenStore) {
		fTokenStore= tokenStore;
		pcps= new ArrayList/*<IPropertyChangeParticipant*/();
	}
	
	protected void addPropertyChangeParticipant(IPropertyChangeParticipant participant) {
		pcps.add(participant);
	}
	
	public IToken nextToken() {
		if (fNeedsLazyColorLoading)
			resolveProxyAttributes();
		return super.nextToken();
	}

	private void resolveProxyAttributes() {
		if (fNeedsLazyColorLoading && Display.getCurrent() != null) {
			for (int i= 0; i < fPropertyNamesColor.length; i++) {
				addToken(fPropertyNamesColor[i], fPropertyNamesBold[i], fPropertyNamesItalic[i], fPropertyNamesStrikethrough[i], fPropertyNamesUnderline[i]);
			}
			fNeedsLazyColorLoading= false;
		}
	}

	private void addTokenWithProxyAttribute(String colorKey, String boldKey, String italicKey, String strikethroughKey, String underlineKey) {
		fTokenMap.put(colorKey, new Token(createTextAttribute(null, boldKey, italicKey, strikethroughKey, underlineKey)));
	}

	private void addToken(String colorKey, String boldKey, String italicKey, String strikethroughKey, String underlineKey) {
		if (fColorManager != null && colorKey != null && fColorManager.getColor(colorKey) == null) {
			RGB rgb= PreferenceConverter.getColor(fPreferenceStore, colorKey);
			if (fColorManager instanceof IColorManagerExtension) {
				IColorManagerExtension ext= (IColorManagerExtension) fColorManager;
				ext.unbindColor(colorKey);
				ext.bindColor(colorKey, rgb);
			}
		}

		if (!fNeedsLazyColorLoading)
			fTokenMap.put(colorKey, new Token(createTextAttribute(colorKey, boldKey, italicKey, strikethroughKey, underlineKey)));
		else {
			Token token= ((Token)fTokenMap.get(colorKey));
			if (token != null)
				token.setData(createTextAttribute(colorKey, boldKey, italicKey, strikethroughKey, underlineKey));
		}
	}

	/**
	 * Convenience method for setting the scanner rules with a list rather
	 * than an array.
	 * @param rules
	 */
	public final void setRules(List/*<IRule>*/ rules) {
		if(rules==null) {
			setRules((IRule[])null);
		} else {
	 * @since 3.0
	 */
	private TextAttribute createTextAttribute(String colorKey, String boldKey, String italicKey, String strikethroughKey, String underlineKey) {
		Color color= null;
		if (colorKey != null)
			color= fColorManager.getColor(colorKey);

		int style= fPreferenceStore.getBoolean(boldKey) ? SWT.BOLD : SWT.NORMAL;
		if (fPreferenceStore.getBoolean(italicKey))
			style |= SWT.ITALIC;

		if (fPreferenceStore.getBoolean(strikethroughKey))
			style |= TextAttribute.STRIKETHROUGH;

		if (fPreferenceStore.getBoolean(underlineKey))
			style |= TextAttribute.UNDERLINE;

		return new TextAttribute(color, null, style);
	}

	protected Token getToken(String key) {
		if (fNeedsLazyColorLoading)
			resolveProxyAttributes();
		return (Token) fTokenMap.get(key);
	}

	private void initializeRules() {
		List rules= createRules();
		if (rules != null) {
			IRule[] result= new IRule[rules.size()];
			rules.toArray(result);
			setRules(result);		
		}
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jface.text.rules.RuleBasedScanner#nextToken()
	 */
	public IToken nextToken() {
		fTokenStore.ensureTokensInitialised();
		return super.nextToken();
		}
		return -1;
	}
	
	public IToken getToken(String key) {
		return fTokenStore.getToken(key);
	}
	
	public IPreferenceStore getPreferenceStore() {
		return fTokenStore.getPreferenceStore();
		int index= indexOf(p);
		Token token= getToken(fPropertyNamesColor[index]);
		if (fPropertyNamesColor[index].equals(p))
			adaptToColorChange(token, event);
		else if (fPropertyNamesBold[index].equals(p))
			adaptToStyleChange(token, event, SWT.BOLD);
		else if (fPropertyNamesItalic[index].equals(p))
			adaptToStyleChange(token, event, SWT.ITALIC);
		else if (fPropertyNamesStrikethrough[index].equals(p))
			adaptToStyleChange(token, event, TextAttribute.STRIKETHROUGH);
		else if (fPropertyNamesUnderline[index].equals(p))
			adaptToStyleChange(token, event, TextAttribute.UNDERLINE);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.cdt.ui.IPropertyChangeParticipant#adaptToPreferenceChange(org.eclipse.jface.util.PropertyChangeEvent)
	 */
	public void adaptToPreferenceChange(PropertyChangeEvent event) {
		if(fTokenStore.affectsBehavior(event)) {
			fTokenStore.adaptToPreferenceChange(event);
			rgb= StringConverter.asRGB((String) value);

		if (rgb != null) {

			String property= event.getProperty();
			Color color= fColorManager.getColor(property);

			if ((color == null || !rgb.equals(color.getRGB())) && fColorManager instanceof IColorManagerExtension) {
				IColorManagerExtension ext= (IColorManagerExtension) fColorManager;

			 	ext.unbindColor(property);
			 	ext.bindColor(property, rgb);

				color= fColorManager.getColor(property);
			}

			Object data= token.getData();
			if (data instanceof TextAttribute) {
				TextAttribute oldAttr= (TextAttribute) data;
				token.setData(new TextAttribute(color, oldAttr.getBackground(), oldAttr.getStyle()));
			}
		}
		for(Iterator i= pcps.iterator(); i.hasNext(); ) {
			((IPropertyChangeParticipant)i.next()).adaptToPreferenceChange(event);
	private void adaptToStyleChange(Token token, PropertyChangeEvent event, int styleAttribute) {
		boolean eventValue= false;
		Object value= event.getNewValue();
		if (value instanceof Boolean)
			eventValue= ((Boolean) value).booleanValue();
		else if (IPreferenceStore.TRUE.equals(value))
			eventValue= true;

		Object data= token.getData();
		if (data instanceof TextAttribute) {
			TextAttribute oldAttr= (TextAttribute) data;
			boolean activeValue= (oldAttr.getStyle() & styleAttribute) == styleAttribute;
			if (activeValue != eventValue)
				token.setData(new TextAttribute(oldAttr.getForeground(), oldAttr.getBackground(), eventValue ? oldAttr.getStyle() | styleAttribute : oldAttr.getStyle() & ~styleAttribute));
		}
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.cdt.ui.IPropertyChangeParticipant#affectsBehavior(org.eclipse.jface.util.PropertyChangeEvent)
	 *
	 * @since 3.0
	 */
	public boolean affectsBehavior(PropertyChangeEvent event) {
		boolean result= fTokenStore.affectsBehavior(event);
		for(Iterator i= pcps.iterator(); !result && i.hasNext(); ) {
			result |= ((IPropertyChangeParticipant)i.next()).affectsBehavior(event);
		}
		return result;
	}
}

Lines 12-18 Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/PreferencesMessages.properties (-1 / +4 lines)
12	# Sergey Prigogin (Google)	12	# Sergey Prigogin (Google)
13	###############################################################################	13	###############################################################################
14		14
15	CEditorPreferencePage_link=C/C++ Editor Preferences. Note that some preferences may be set on the <a href="org.eclipse.ui.preferencePages.GeneralTextEditor">Text Editors</a> preference page.	15	CEditorPreferencePage_link=C/C++ Editor Preferences. General preferences may be set via <a href="org.eclipse.ui.preferencePages.GeneralTextEditor">Text Editors</a>.
16	CEditorPreferencePage_link_tooltip=Show the shared text editor preferences	16	CEditorPreferencePage_link_tooltip=Show the shared text editor preferences
17		17
18	CEditorPreferencePage_colors=Synta&x	18	CEditorPreferencePage_colors=Synta&x
Lines 191-199 Link Here
191	CEditorPreferencePage_closeBraces={B&races}	191	CEditorPreferencePage_closeBraces={B&races}
192	CEditorPreferencePage_wrapStrings=&Wrap automatically	192	CEditorPreferencePage_wrapStrings=&Wrap automatically
193	CEditorPreferencePage_escapeStrings=Escape text w&hen pasting into a string literal	193	CEditorPreferencePage_escapeStrings=Escape text w&hen pasting into a string literal
		194	CEditorPreferencePage_GeneralAppearanceGroupTitle=General appearance
		195	CEditorPreferencePage_SelectDocToolDescription=Select the documentation tool to be used to determine editor behaviors when no project preference overrides exist
194	CEditorPreferencePage_smartPaste=Adjust &indentation	196	CEditorPreferencePage_smartPaste=Adjust &indentation
195		197
196	CEditorPreferencePage_typing_smartTab= &Tab key indents the current line	198	CEditorPreferencePage_typing_smartTab= &Tab key indents the current line
		199	CEditorPreferencePage_WorkspaceDefaultLabel=Workspace default:
197		200
198	# Code Formatting	201	# Code Formatting
199	CodeFormatterPreferencePage_title=Code Style	202	CodeFormatterPreferencePage_title=Code Style

Lines 181-189 Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/PreferencesMessages.java (+3 lines)
181	public static String CEditorPreferencePage_closeBraces;	181	public static String CEditorPreferencePage_closeBraces;
182	public static String CEditorPreferencePage_wrapStrings;	182	public static String CEditorPreferencePage_wrapStrings;
183	public static String CEditorPreferencePage_escapeStrings;	183	public static String CEditorPreferencePage_escapeStrings;
		184	public static String CEditorPreferencePage_GeneralAppearanceGroupTitle;
		185	public static String CEditorPreferencePage_SelectDocToolDescription;
184	public static String CEditorPreferencePage_smartPaste;	186	public static String CEditorPreferencePage_smartPaste;
185		187
186	public static String CEditorPreferencePage_typing_smartTab;	188	public static String CEditorPreferencePage_typing_smartTab;
		189	public static String CEditorPreferencePage_WorkspaceDefaultLabel;
187		190
188	public static String SmartTypingConfigurationBlock_autoclose_title;	191	public static String SmartTypingConfigurationBlock_autoclose_title;
189	public static String SmartTypingConfigurationBlock_tabs_title;	192	public static String SmartTypingConfigurationBlock_tabs_title;

Lines 801-807 Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/CEditorColoringConfigurationBlock.java (-1 / +1 lines)
801		801
802	String content= loadPreviewContentFromFile("ColorSettingPreviewCode.txt"); //$NON-NLS-1$	802	String content= loadPreviewContentFromFile("ColorSettingPreviewCode.txt"); //$NON-NLS-1$
803	IDocument document= new Document(content);	803	IDocument document= new Document(content);
804	CUIPlugin.getDefault().getTextTools().setupCDocumentPartitioner(document, ICPartitions.C_PARTITIONING);	804	CUIPlugin.getDefault().getTextTools().setupCDocumentPartitioner(document, ICPartitions.C_PARTITIONING, null);
805	fPreviewViewer.setDocument(document);	805	fPreviewViewer.setDocument(document);
806		806
807	installSemanticHighlighting();	807	installSemanticHighlighting();

Lines 409-415 Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/CodeTemplateBlock.java (-1 / +1 lines)
409		409
410	IDocument document= new Document();	410	IDocument document= new Document();
411	CTextTools tools= CUIPlugin.getDefault().getTextTools();	411	CTextTools tools= CUIPlugin.getDefault().getTextTools();
412	tools.setupCDocumentPartitioner(document, ICPartitions.C_PARTITIONING);	412	tools.setupCDocumentPartitioner(document, ICPartitions.C_PARTITIONING, null);
413	IPreferenceStore store= CUIPlugin.getDefault().getCombinedPreferenceStore();	413	IPreferenceStore store= CUIPlugin.getDefault().getCombinedPreferenceStore();
414	SourceViewer viewer= new CSourceViewer(parent, null, null, false, SWT.BORDER \| SWT.V_SCROLL \| SWT.H_SCROLL, store);	414	SourceViewer viewer= new CSourceViewer(parent, null, null, false, SWT.BORDER \| SWT.V_SCROLL \| SWT.H_SCROLL, store);
415	CodeTemplateSourceViewerConfiguration configuration= new CodeTemplateSourceViewerConfiguration(tools.getColorManager(), store, null, fTemplateProcessor);	415	CodeTemplateSourceViewerConfiguration configuration= new CodeTemplateSourceViewerConfiguration(tools.getColorManager(), store, null, fTemplateProcessor);

Lines 413-419 Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/EditTemplateDialog.java (-1 / +1 lines)
413	String prefix= getPrefix();	413	String prefix= getPrefix();
414	IDocument document= new Document(prefix + fTemplate.getPattern());	414	IDocument document= new Document(prefix + fTemplate.getPattern());
415	CTextTools tools= CUIPlugin.getDefault().getTextTools();	415	CTextTools tools= CUIPlugin.getDefault().getTextTools();
416	tools.setupCDocumentPartitioner(document, ICPartitions.C_PARTITIONING);	416	tools.setupCDocumentPartitioner(document, ICPartitions.C_PARTITIONING, null);
417	IPreferenceStore store= CUIPlugin.getDefault().getCombinedPreferenceStore();	417	IPreferenceStore store= CUIPlugin.getDefault().getCombinedPreferenceStore();
418	SourceViewer viewer= new CSourceViewer(parent, null, null, false, SWT.BORDER \| SWT.V_SCROLL \| SWT.H_SCROLL, store);	418	SourceViewer viewer= new CSourceViewer(parent, null, null, false, SWT.BORDER \| SWT.V_SCROLL \| SWT.H_SCROLL, store);
419	CodeTemplateSourceViewerConfiguration configuration= new CodeTemplateSourceViewerConfiguration(tools.getColorManager(), store, null, fTemplateProcessor);	419	CodeTemplateSourceViewerConfiguration configuration= new CodeTemplateSourceViewerConfiguration(tools.getColorManager(), store, null, fTemplateProcessor);

Lines 14-19 Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/CEditorPreferencePage.java (-4 / +28 lines)
14		14
15	import java.util.ArrayList;	15	import java.util.ArrayList;
16		16
		17	import org.eclipse.jface.layout.GridDataFactory;
17	import org.eclipse.jface.preference.ColorSelector;	18	import org.eclipse.jface.preference.ColorSelector;
18	import org.eclipse.jface.preference.IPreferenceStore;	19	import org.eclipse.jface.preference.IPreferenceStore;
19	import org.eclipse.jface.preference.PreferenceConverter;	20	import org.eclipse.jface.preference.PreferenceConverter;
Lines 37-46 Link Here
37	import org.eclipse.ui.dialogs.PreferencesUtil;	38	import org.eclipse.ui.dialogs.PreferencesUtil;
38		39
39	import org.eclipse.cdt.ui.PreferenceConstants;	40	import org.eclipse.cdt.ui.PreferenceConstants;
		41	import org.eclipse.cdt.ui.dialogs.DocCommentOwnerComposite;
		42	import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
		43	import org.eclipse.cdt.utils.ui.controls.ControlFactory;
40		44
41	import org.eclipse.cdt.internal.ui.ICHelpContextIds;	45	import org.eclipse.cdt.internal.ui.ICHelpContextIds;
42	import org.eclipse.cdt.internal.ui.editor.CEditor;	46	import org.eclipse.cdt.internal.ui.editor.CEditor;
43	import org.eclipse.cdt.internal.ui.text.contentassist.ContentAssistPreference;	47	import org.eclipse.cdt.internal.ui.text.contentassist.ContentAssistPreference;
		48	import org.eclipse.cdt.internal.ui.text.doctools.DocCommentOwnerManager;
44		49
45	/*	50	/*
46	* The page for setting the editor options.	51	* The page for setting the editor options.
Lines 60-67 Link Here
60	private List fAppearanceColorList;	65	private List fAppearanceColorList;
61	private ColorSelector fAppearanceColorEditor;	66	private ColorSelector fAppearanceColorEditor;
62	private Button fAppearanceColorDefault;	67	private Button fAppearanceColorDefault;
63		68	private DocCommentOwnerComposite fDocCommentOwnerComposite;
64		69
65	public CEditorPreferencePage() {	70	public CEditorPreferencePage() {
66	super();	71	super();
67	}	72	}
Lines 117-124 Link Here
117	}	122	}
118		123
119	private Control createAppearancePage(Composite parent) {	124	private Control createAppearancePage(Composite parent) {
120		125	Composite behaviorComposite= ControlFactory.createGroup(parent, PreferencesMessages.CEditorPreferencePage_GeneralAppearanceGroupTitle, 1);
121	Composite behaviorComposite = new Composite(parent, SWT.NONE);	126
		127	// Composite behaviorComposite = new Composite(parent, SWT.NONE);
122	GridLayout layout = new GridLayout();	128	GridLayout layout = new GridLayout();
123	layout.numColumns = 2;	129	layout.numColumns = 2;
124	behaviorComposite.setLayout(layout);	130	behaviorComposite.setLayout(layout);
Lines 216-221 Link Here
216	PreferenceConverter.setValue(fOverlayStore, key, fAppearanceColorEditor.getColorValue());	222	PreferenceConverter.setValue(fOverlayStore, key, fAppearanceColorEditor.getColorValue());
217	}	223	}
218	});	224	});
		225
219	return behaviorComposite;	226	return behaviorComposite;
220	}	227	}
221		228
Lines 269-276 Link Here
269		276
270	createHeader(parent);	277	createHeader(parent);
271		278
		279	ControlFactory.createEmptySpace(parent, 2);
272	createAppearancePage(parent);	280	createAppearancePage(parent);
273		281
		282	ControlFactory.createEmptySpace(parent, 2);
		283
		284	String dsc= PreferencesMessages.CEditorPreferencePage_SelectDocToolDescription;
		285	String msg= PreferencesMessages.CEditorPreferencePage_WorkspaceDefaultLabel;
		286	IDocCommentOwner workspaceOwner= DocCommentOwnerManager.getInstance().getWorkspaceCommentOwner();
		287	fDocCommentOwnerComposite= new DocCommentOwnerComposite(parent, workspaceOwner, dsc, msg);
		288	fDocCommentOwnerComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true,false).create());
		289
274	initialize();	290	initialize();
275		291
276	return parent;	292	return parent;
Lines 291-296 Link Here
291	});	307	});
292	}	308	}
293		309
		310	/*
		311	* @see org.eclipse.cdt.internal.ui.preferences.AbstractPreferencePage#performOk()
		312	*/
		313	public boolean performOk() {
		314	DocCommentOwnerManager.getInstance().setWorkspaceCommentOwner(fDocCommentOwnerComposite.getSelectedDocCommentOwner());
		315	return super.performOk();
		316	}
		317
294	/**	318	/**
295	* Initializes the default colors.	319	* Initializes the default colors.
296	*/	320	*/

Lines 157-163 Link Here

(-)src/org/eclipse/cdt/internal/ui/compare/CStructureCreator.java (-1 / +1 lines)
157	* @see org.eclipse.compare.structuremergeviewer.StructureCreator#getDocumentPartitioner()	157	* @see org.eclipse.compare.structuremergeviewer.StructureCreator#getDocumentPartitioner()
158	*/	158	*/
159	protected IDocumentPartitioner getDocumentPartitioner() {	159	protected IDocumentPartitioner getDocumentPartitioner() {
160	return CUIPlugin.getDefault().getTextTools().createDocumentPartitioner();	160	return CUIPlugin.getDefault().getTextTools().createDocumentPartitioner(null);
161	}	161	}
162		162
163	private static String readString(IStreamContentAccessor sa) throws CoreException {	163	private static String readString(IStreamContentAccessor sa) throws CoreException {

Lines 134-140 Link Here

(-)src/org/eclipse/cdt/internal/ui/compare/AbstractMergeViewer.java (-1 / +1 lines)
134	}	134	}
135		135
136	protected IDocumentPartitioner getDocumentPartitioner() {	136	protected IDocumentPartitioner getDocumentPartitioner() {
137	return CUIPlugin.getDefault().getTextTools().createDocumentPartitioner();	137	return CUIPlugin.getDefault().getTextTools().createDocumentPartitioner(null);
138	}	138	}
139		139
140	protected void configureTextViewer(TextViewer textViewer) {	140	protected void configureTextViewer(TextViewer textViewer) {

Lines 34-39 Link Here

(-)META-INF/MANIFEST.MF (+4 lines)
34	org.eclipse.cdt.internal.ui.text.asm;x-internal:=true,	34	org.eclipse.cdt.internal.ui.text.asm;x-internal:=true,
35	org.eclipse.cdt.internal.ui.text.c.hover;x-internal:=true,	35	org.eclipse.cdt.internal.ui.text.c.hover;x-internal:=true,
36	org.eclipse.cdt.internal.ui.text.contentassist;x-internal:=true,	36	org.eclipse.cdt.internal.ui.text.contentassist;x-internal:=true,
		37	org.eclipse.cdt.internal.ui.text.doctools;x-internal:=true,
		38	org.eclipse.cdt.internal.ui.text.doctools.doxygen;x-internal:=true,
37	org.eclipse.cdt.internal.ui.text.folding;x-internal:=true,	39	org.eclipse.cdt.internal.ui.text.folding;x-internal:=true,
38	org.eclipse.cdt.internal.ui.text.template;x-internal:=true,	40	org.eclipse.cdt.internal.ui.text.template;x-internal:=true,
39	org.eclipse.cdt.internal.ui.text.util;x-internal:=true,	41	org.eclipse.cdt.internal.ui.text.util;x-internal:=true,
Lines 59-64 Link Here
59	org.eclipse.cdt.ui.text,	61	org.eclipse.cdt.ui.text,
60	org.eclipse.cdt.ui.text.c.hover,	62	org.eclipse.cdt.ui.text.c.hover,
61	org.eclipse.cdt.ui.text.contentassist,	63	org.eclipse.cdt.ui.text.contentassist,
		64	org.eclipse.cdt.ui.text.doctools,
		65	org.eclipse.cdt.ui.text.doctools.generic,
62	org.eclipse.cdt.ui.text.folding,	66	org.eclipse.cdt.ui.text.folding,
63	org.eclipse.cdt.ui.wizards,	67	org.eclipse.cdt.ui.wizards,
64	org.eclipse.cdt.ui.wizards.conversion,	68	org.eclipse.cdt.ui.wizards.conversion,




/*******************************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation and others.
 * 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

 *     IBM Corporation - initial API and implementation
 *     QNX Software System
 *     Anton Leherbauer (Wind River Systems)
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.editor.asm;

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

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.rules.EndOfLineRule;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.WhitespaceRule;
import org.eclipse.jface.text.rules.WordPatternRule;
import org.eclipse.jface.text.rules.WordRule;
import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.cdt.core.model.IAsmLanguage;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;

import org.eclipse.cdt.internal.ui.text.AbstractCScanner;
import org.eclipse.cdt.internal.ui.text.ICColorConstants;
import org.eclipse.cdt.internal.ui.text.IColorManager;
import org.eclipse.cdt.internal.ui.text.util.CWhitespaceDetector;


/*
 * An assembly code scanner.
 */
public final class AsmCodeScanner extends AbstractCScanner {

	/**
	 * Creates an assembly code scanner.
	 */
	public AsmCodeScanner(ITokenStoreFactory factory, IAsmLanguage asmLanguage) {
		super(factory.createTokenStore(fgTokenProperties));
		fAsmLanguage= asmLanguage;
		setRules(createRules());
	}
	
	/*
	 * @see AbstractCScanner#getTokenProperties()
	 */
	protected String[] getTokenProperties() {
		return fgTokenProperties;
	}

	/*

				
		List rules= new ArrayList();		
		
		IToken token;

		// Add rule(s) for single line comments
		token= getToken(ICColorConstants.C_SINGLE_LINE_COMMENT);

		// Add generic whitespace rule.
		rules.add(new WhitespaceRule(new CWhitespaceDetector()));

		final IToken other= getToken(ICColorConstants.C_DEFAULT);		

		// Add rule for labels
		token= getToken(ICColorConstants.ASM_LABEL);

		setDefaultReturnToken(other);
		return rules;
	}

	/*
	 * @see AbstractCScanner#adaptToPreferenceChange(PropertyChangeEvent)
	 */
	public void adaptToPreferenceChange(PropertyChangeEvent event) {
		if (super.affectsBehavior(event)) {
			super.adaptToPreferenceChange(event);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation and others.
 * 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

 *     IBM Corporation - initial API and implementation
 *     QNX Software System
 *     Wind River Systems, Inc.
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.editor.asm;



import org.eclipse.cdt.core.model.AssemblyLanguage;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.ITokenStore;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;

import org.eclipse.cdt.internal.ui.text.CCommentScanner;
import org.eclipse.cdt.internal.ui.text.ICColorConstants;
import org.eclipse.cdt.internal.ui.text.SingleTokenCScanner;
import org.eclipse.cdt.internal.ui.text.TokenStore;
import org.eclipse.cdt.internal.ui.text.util.CColorManager;



     * and initializes all members of this collection.
     */
    public AsmTextTools(IPreferenceStore store, Preferences coreStore) {
    	fPreferenceStore = store != null ? store : CUIPlugin.getDefault().getPreferenceStore();
    	fColorManager= new CColorManager();
    	
		ITokenStoreFactory factory= new ITokenStoreFactory() {
			public ITokenStore createTokenStore(String[] propertyColorNames) {
				return new TokenStore(fColorManager, fPreferenceStore, propertyColorNames);
			}
		};

		fCodeScanner= new AsmCodeScanner(factory, AssemblyLanguage.getDefault());
		fPreprocessorScanner= new AsmPreprocessorScanner(factory, AssemblyLanguage.getDefault());
        fMultilineCommentScanner= new CCommentScanner(factory, coreStore, ICColorConstants.C_MULTI_LINE_COMMENT);
        fSinglelineCommentScanner= new CCommentScanner(factory, coreStore, ICColorConstants.C_SINGLE_LINE_COMMENT);
		fStringScanner= new SingleTokenCScanner(factory, ICColorConstants.C_STRING);

		// listener must be registered after initializing scanners
        fPreferenceStore.addPropertyChangeListener(fPreferenceListener);
        
        fCorePreferenceStore= coreStore;
        if (fCorePreferenceStore != null) {




/*******************************************************************************
 * Copyright (c) 2006, 2008 Wind River Systems, Inc. and others.
 * 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

 *
 * Contributors:
 *     Anton Leherbauer (Wind River Systems) - initial API and implementation
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.editor.asm;


import java.util.List;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.rules.EndOfLineRule;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.WhitespaceRule;

import org.eclipse.cdt.core.model.IAsmLanguage;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;

import org.eclipse.cdt.internal.ui.text.AbstractCScanner;
import org.eclipse.cdt.internal.ui.text.CHeaderRule;
import org.eclipse.cdt.internal.ui.text.ICColorConstants;
import org.eclipse.cdt.internal.ui.text.IColorManager;
import org.eclipse.cdt.internal.ui.text.PreprocessorRule;
import org.eclipse.cdt.internal.ui.text.util.CWhitespaceDetector;
import org.eclipse.cdt.internal.ui.text.util.CWordDetector;


	/**
	 * Create a preprocessor directive scanner.
	 * @param factory
     * @param asmLanguage
	 * @param store
	 * @param asmLanguage
	 */
	public AsmPreprocessorScanner(ITokenStoreFactory factory, IAsmLanguage asmLanguage) {
		super(factory.createTokenStore(fgTokenProperties));
		Assert.isNotNull(asmLanguage);
		fAsmLanguage= asmLanguage;
		setRules(createRules());
	}

	/**
	 * Creates rules used in this RulesBasedScanner
	 */
	protected List createRules() {
		IToken defaultToken= getToken(ICColorConstants.PP_DEFAULT);
		Token defaultToken= getToken(ICColorConstants.PP_DEFAULT);

		List rules= new ArrayList();		
		IToken token;
		
		// Add generic white space rule.
		rules.add(new WhitespaceRule(new CWhitespaceDetector()));

        setDefaultReturnToken(defaultToken);
		return rules;
	}

	/*
	 * @see org.eclipse.cdt.internal.ui.text.AbstractCScanner#getTokenProperties()
	 */
	protected String[] getTokenProperties() {
		return fgTokenProperties;
	}

}

Lines 1-5 Link Here

(-)src/org/eclipse/cdt/internal/ui/editor/asm/AsmSourceViewerConfiguration.java (-8 / +18 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 QNX Software Systems and others.	2	* Copyright (c) 2000, 2008 QNX Software Systems and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 44-49 Link Here
44	import org.eclipse.cdt.ui.CUIPlugin;	44	import org.eclipse.cdt.ui.CUIPlugin;
45	import org.eclipse.cdt.ui.ILanguageUI;	45	import org.eclipse.cdt.ui.ILanguageUI;
46	import org.eclipse.cdt.ui.text.ICPartitions;	46	import org.eclipse.cdt.ui.text.ICPartitions;
		47	import org.eclipse.cdt.ui.text.ITokenStore;
		48	import org.eclipse.cdt.ui.text.ITokenStoreFactory;
47		49
48	import org.eclipse.cdt.internal.ui.text.AbstractCScanner;	50	import org.eclipse.cdt.internal.ui.text.AbstractCScanner;
49	import org.eclipse.cdt.internal.ui.text.CCommentScanner;	51	import org.eclipse.cdt.internal.ui.text.CCommentScanner;
Lines 52-57 Link Here
52	import org.eclipse.cdt.internal.ui.text.IColorManager;	54	import org.eclipse.cdt.internal.ui.text.IColorManager;
53	import org.eclipse.cdt.internal.ui.text.PartitionDamager;	55	import org.eclipse.cdt.internal.ui.text.PartitionDamager;
54	import org.eclipse.cdt.internal.ui.text.SingleTokenCScanner;	56	import org.eclipse.cdt.internal.ui.text.SingleTokenCScanner;
		57	import org.eclipse.cdt.internal.ui.text.TokenStore;
55		58
56		59
57	public class AsmSourceViewerConfiguration extends TextSourceViewerConfiguration {	60	public class AsmSourceViewerConfiguration extends TextSourceViewerConfiguration {
Lines 123-131 Link Here
123	* Initializes the scanners.	126	* Initializes the scanners.
124	*/	127	*/
125	private void initializeScanners() {	128	private void initializeScanners() {
126	fMultilineCommentScanner= new CCommentScanner(getColorManager(), fPreferenceStore, ICColorConstants.C_MULTI_LINE_COMMENT);	129	fMultilineCommentScanner= new CCommentScanner(getTokenStoreFactory(), ICColorConstants.C_MULTI_LINE_COMMENT);
127	fSinglelineCommentScanner= new CCommentScanner(getColorManager(), fPreferenceStore, ICColorConstants.C_SINGLE_LINE_COMMENT);	130	fSinglelineCommentScanner= new CCommentScanner(getTokenStoreFactory(), ICColorConstants.C_SINGLE_LINE_COMMENT);
128	fStringScanner= new SingleTokenCScanner(getColorManager(), fPreferenceStore, ICColorConstants.C_STRING);	131	fStringScanner= new SingleTokenCScanner(getTokenStoreFactory(), ICColorConstants.C_STRING);
129	}	132	}
130		133
131	/**	134	/**
Lines 167-176 Link Here
167	}	170	}
168	AbstractCScanner scanner= null;	171	AbstractCScanner scanner= null;
169	if (language instanceof IAsmLanguage) {	172	if (language instanceof IAsmLanguage) {
170	scanner= new AsmPreprocessorScanner(getColorManager(), fPreferenceStore, (IAsmLanguage)language);	173	scanner= new AsmPreprocessorScanner(getTokenStoreFactory(), (IAsmLanguage)language);
171	}	174	}
172	if (scanner == null) {	175	if (scanner == null) {
173	scanner= new AsmPreprocessorScanner(getColorManager(), fPreferenceStore, AssemblyLanguage.getDefault());	176	scanner= new AsmPreprocessorScanner(getTokenStoreFactory(), AssemblyLanguage.getDefault());
174	}	177	}
175	fPreprocessorScanner= scanner;	178	fPreprocessorScanner= scanner;
176	return fPreprocessorScanner;	179	return fPreprocessorScanner;
Lines 187-200 Link Here
187	RuleBasedScanner scanner= null;	190	RuleBasedScanner scanner= null;
188	if (language instanceof IAsmLanguage) {	191	if (language instanceof IAsmLanguage) {
189	IAsmLanguage asmLang= (IAsmLanguage)language;	192	IAsmLanguage asmLang= (IAsmLanguage)language;
190	scanner = new AsmCodeScanner(getColorManager(), fPreferenceStore, asmLang);	193	scanner = new AsmCodeScanner(getTokenStoreFactory(), asmLang);
191	} else if (language != null) {	194	} else if (language != null) {
192	ILanguageUI languageUI = (ILanguageUI)language.getAdapter(ILanguageUI.class);	195	ILanguageUI languageUI = (ILanguageUI)language.getAdapter(ILanguageUI.class);
193	if (languageUI != null)	196	if (languageUI != null)
194	scanner = languageUI.getCodeScanner();	197	scanner = languageUI.getCodeScanner();
195	}	198	}
196	if (scanner == null) {	199	if (scanner == null) {
197	scanner = new AsmCodeScanner(getColorManager(), fPreferenceStore, AssemblyLanguage.getDefault());	200	scanner = new AsmCodeScanner(getTokenStoreFactory(), AssemblyLanguage.getDefault());
198	}	201	}
199	if (scanner instanceof AbstractCScanner) {	202	if (scanner instanceof AbstractCScanner) {
200	fCodeScanner= (AbstractCScanner)scanner;	203	fCodeScanner= (AbstractCScanner)scanner;
Lines 373-378 Link Here
373	fPreprocessorScanner= null;	376	fPreprocessorScanner= null;
374	}	377	}
375		378
		379	private ITokenStoreFactory getTokenStoreFactory() {
		380	return new ITokenStoreFactory() {
		381	public ITokenStore createTokenStore(String[] propertyColorNames) {
		382	return new TokenStore(getColorManager(), fPreferenceStore, propertyColorNames);
		383	}
		384	};
		385	}
376	}	386	}
377		387
378		388

Lines 22-27 Link Here

(-)src/org/eclipse/cdt/ui/dialogs/DialogsMessages.properties (+5 lines)
22	CacheSizeBlock_absoluteLimit=Absolute Limit:	22	CacheSizeBlock_absoluteLimit=Absolute Limit:
23	CacheSizeBlock_MB=MB	23	CacheSizeBlock_MB=MB
24	CacheSizeBlock_headerFileCache=Header file cache (used by full indexer and refactoring):	24	CacheSizeBlock_headerFileCache=Header file cache (used by full indexer and refactoring):
		25	DocCommentOwnerBlock_DocToolLabel=Documentation tool:
		26	DocCommentOwnerBlock_EnableProjectSpecificSettings=Enable project specific settings
		27	DocCommentOwnerBlock_SelectDocToolDescription=Select the documentation tool to be used to determine editor behaviors in this project
		28	DocCommentOwnerCombo_None=None
		29	DocCommentOwnerComposite_DocumentationToolGroupTitle=Documentation tool comments
25	IndexerStrategyBlock_strategyGroup=Indexing strategy	30	IndexerStrategyBlock_strategyGroup=Indexing strategy
26	IndexerStrategyBlock_autoUpdate=Automatically update the index	31	IndexerStrategyBlock_autoUpdate=Automatically update the index
27	IndexerBlock_fixedBuildConfig=Use a fixed build configuration	32	IndexerBlock_fixedBuildConfig=Use a fixed build configuration

Lines 37-42 Link Here

(-)src/org/eclipse/cdt/ui/dialogs/DialogsMessages.java (+6 lines)
37	public static String CacheSizeBlock_indexDatabaseCache;	37	public static String CacheSizeBlock_indexDatabaseCache;
38	public static String CacheSizeBlock_limitRelativeToMaxHeapSize;	38	public static String CacheSizeBlock_limitRelativeToMaxHeapSize;
39		39
		40	public static String DocCommentOwnerBlock_DocToolLabel;
		41	public static String DocCommentOwnerBlock_EnableProjectSpecificSettings;
		42	public static String DocCommentOwnerBlock_SelectDocToolDescription;
		43	public static String DocCommentOwnerCombo_None;
		44	public static String DocCommentOwnerComposite_DocumentationToolGroupTitle;
		45
40	static {	46	static {
41	// initialize resource bundle	47	// initialize resource bundle
42	NLS.initializeMessages(BUNDLE_NAME, DialogsMessages.class);	48	NLS.initializeMessages(BUNDLE_NAME, DialogsMessages.class);

Lines 23-28 Link Here

(-)plugin.xml (-11 / +55 lines)
23	<extension-point id="ConfigManager" name="%ConfigManager" schema="schema/ConfigManager.exsd"/>	23	<extension-point id="ConfigManager" name="%ConfigManager" schema="schema/ConfigManager.exsd"/>
24	<extension-point id="HelpInfo" name="%HelpInfo" schema="schema/HelpInfo.exsd"/>	24	<extension-point id="HelpInfo" name="%HelpInfo" schema="schema/HelpInfo.exsd"/>
25	<extension-point id="quickFixProcessors" name="%quickFixProcessorExtensionPoint" schema="schema/quickFixProcessors.exsd"/>	25	<extension-point id="quickFixProcessors" name="%quickFixProcessorExtensionPoint" schema="schema/quickFixProcessors.exsd"/>
		26	<extension-point id="DocCommentOwner" name="%extension-point.name.0" schema="schema/DocCommentOwner.exsd"/>
26		27
27	<extension	28	<extension
28	point="org.eclipse.core.runtime.adapters">	29	point="org.eclipse.core.runtime.adapters">
Lines 770-775 Link Here
770	class="org.eclipse.cdt.internal.ui.preferences.WorkInProgressPreferencePage"	771	class="org.eclipse.cdt.internal.ui.preferences.WorkInProgressPreferencePage"
771	id="org.eclipse.cdt.ui.preferneces.WorkInProgressPreferencePage">	772	id="org.eclipse.cdt.ui.preferneces.WorkInProgressPreferencePage">
772	</page-->	773	</page-->
		774	<page
		775	class="org.eclipse.cdt.ui.templateengine.pages.TemplatePreferencePage"
		776	name="%TemplatePreferencePage.name"
		777	category="org.eclipse.cdt.ui.preferences.CPluginPreferencePage"
		778	id="org.eclipse.cdt.core.templateengine.shareddefaults"/>
		779	<page
		780	category="org.eclipse.cdt.ui.preferences.CEditorPreferencePage"
		781	class="org.eclipse.cdt.ui.text.doctools.DocToolsPreferencePage"
		782	id="org.eclipse.cdt.ui.text.doctools.prefpage"
		783	name="Doc. Comments"/>
773	</extension>	784	</extension>
774	<extension	785	<extension
775	point="org.eclipse.ui.editorActions">	786	point="org.eclipse.ui.editorActions">
Lines 2434-2449 Link Here
2434	name="%exportWizard.CDTCategory.name">	2445	name="%exportWizard.CDTCategory.name">
2435	</category>	2446	</category>
2436	</extension>	2447	</extension>
2437
2438	<extension
2439	point="org.eclipse.ui.preferencePages">
2440	<page
2441	class="org.eclipse.cdt.ui.templateengine.pages.TemplatePreferencePage"
2442	name="%TemplatePreferencePage.name"
2443	category="org.eclipse.cdt.ui.preferences.CPluginPreferencePage"
2444	id="org.eclipse.cdt.core.templateengine.shareddefaults"/>
2445	</extension>
2446
2447	<extension	2448	<extension
2448	id="TemplateEngineWizard"	2449	id="TemplateEngineWizard"
2449	name="%Template.Engine.Wizard"	2450	name="%Template.Engine.Wizard"
Lines 2463-2473 Link Here
2463	</updater>	2464	</updater>
2464	</extension>	2465	</extension>
2465	<extension	2466	<extension
		2467	id="id1"
		2468	point="org.eclipse.cdt.ui.completionProposalComputer">
		2469	<completionProposalComputer
		2470	activate="true"
		2471	categoryId="org.eclipse.cdt.ui.parserProposalCategory"
		2472	class="org.eclipse.cdt.internal.ui.text.doctools.DocCommentMultilineProposalComputer">
		2473	<partition
		2474	type="__c_multiline_doc_comment">
		2475	</partition>
		2476	</completionProposalComputer>
		2477	</extension>
		2478	<extension
		2479	id="id2"
		2480	point="org.eclipse.cdt.ui.completionProposalComputer">
		2481	<completionProposalComputer
		2482	activate="true"
		2483	categoryId="org.eclipse.cdt.ui.parserProposalCategory"
		2484	class="org.eclipse.cdt.internal.ui.text.doctools.DocCommentSinglelineProposalComputer">
		2485	<partition
		2486	type="__c_singleline_doc_comment">
		2487	</partition>
		2488	</completionProposalComputer>
		2489	</extension>
		2490	<extension
2466	point="org.eclipse.cdt.ui.CHelpProvider">	2491	point="org.eclipse.cdt.ui.CHelpProvider">
2467	<provider	2492	<provider
2468	class="org.eclipse.cdt.internal.ui.help.CHelpProvider"	2493	class="org.eclipse.cdt.internal.ui.help.CHelpProvider"
2469	id="org.eclipse.cdt.ui.provider1">	2494	id="org.eclipse.cdt.ui.provider1">
2470	</provider>	2495	</provider>
2471	</extension>	2496	</extension>
2472		2497
		2498	<!-- -->
		2499	<extension
		2500	point="org.eclipse.cdt.ui.DocCommentOwner">
		2501	<owner
		2502	id="org.eclipse.cdt.ui.doxygen"
		2503	name="Doxygen"
		2504	multiline="org.eclipse.cdt.internal.ui.text.doctools.doxygen.DoxygenMultilineConfiguration"
		2505	singleline="org.eclipse.cdt.internal.ui.text.doctools.doxygen.DoxygenSingleConfiguration">
		2506	</owner>
		2507	</extension>
		2508	<extension
		2509	point="org.eclipse.cdt.ui.DocCommentOwner">
		2510	<owner
		2511	id="org.eclipse.cdt.ui.docpp"
		2512	name="Doc++"
		2513	multiline="org.eclipse.cdt.internal.ui.text.doctools.docpp.DocppMultilineConfiguration"
		2514	singleline="org.eclipse.cdt.internal.ui.text.doctools.docpp.DocppSingleConfiguration">
		2515	</owner>
		2516	</extension>
2473	</plugin>	2517	</plugin>

Lines 447-449 Link Here

(-)plugin.properties (+2 lines)
447	toggleMarkOccurrences.description= Toggles mark occurrences in C/C++ editors	447	toggleMarkOccurrences.description= Toggles mark occurrences in C/C++ editors
448		448
449	OccurrenceAnnotation.label= C/C++ Occurrences	449	OccurrenceAnnotation.label= C/C++ Occurrences
		450
		451	extension-point.name.0 = DocCommentOwner

Lines 15-20 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/spelling/CSpellingEngine.java (+42 lines)
15	import org.eclipse.core.runtime.IProgressMonitor;	15	import org.eclipse.core.runtime.IProgressMonitor;
16	import org.eclipse.jface.text.BadLocationException;	16	import org.eclipse.jface.text.BadLocationException;
17	import org.eclipse.jface.text.IDocument;	17	import org.eclipse.jface.text.IDocument;
		18	import org.eclipse.jface.text.IDocumentExtension3;
		19	import org.eclipse.jface.text.IDocumentPartitioner;
18	import org.eclipse.jface.text.IRegion;	20	import org.eclipse.jface.text.IRegion;
19	import org.eclipse.jface.text.ITypedRegion;	21	import org.eclipse.jface.text.ITypedRegion;
20	import org.eclipse.jface.text.TextUtilities;	22	import org.eclipse.jface.text.TextUtilities;
Lines 25-33 Link Here
25		27
26	import org.eclipse.cdt.ui.CUIPlugin;	28	import org.eclipse.cdt.ui.CUIPlugin;
27	import org.eclipse.cdt.ui.text.ICPartitions;	29	import org.eclipse.cdt.ui.text.ICPartitions;
		30	import org.eclipse.cdt.ui.text.doctools.IDocCommentDictionary;
		31	import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
		32	import org.eclipse.cdt.ui.text.doctools.IDocCommentSimpleDictionary;
28		33
29	import org.eclipse.cdt.internal.ui.text.CTextTools;	34	import org.eclipse.cdt.internal.ui.text.CTextTools;
		35	import org.eclipse.cdt.internal.ui.text.FastCPartitioner;
		36	import org.eclipse.cdt.internal.ui.text.doctools.DocCommentSpellDictionary;
30	import org.eclipse.cdt.internal.ui.text.spelling.engine.ISpellChecker;	37	import org.eclipse.cdt.internal.ui.text.spelling.engine.ISpellChecker;
		38	import org.eclipse.cdt.internal.ui.text.spelling.engine.ISpellDictionary;
31	import org.eclipse.cdt.internal.ui.text.spelling.engine.ISpellEventListener;	39	import org.eclipse.cdt.internal.ui.text.spelling.engine.ISpellEventListener;
32		40
33	/**	41	/**
Lines 40-47 Link Here
40	protected void check(IDocument document, IRegion[] regions, ISpellChecker checker, ISpellingProblemCollector collector, IProgressMonitor monitor) {	48	protected void check(IDocument document, IRegion[] regions, ISpellChecker checker, ISpellingProblemCollector collector, IProgressMonitor monitor) {
41	ISpellEventListener listener= new SpellEventListener(collector, document);	49	ISpellEventListener listener= new SpellEventListener(collector, document);
42	boolean isIgnoringStringLiterals= SpellingPreferences.isIgnoreStringLiterals();	50	boolean isIgnoringStringLiterals= SpellingPreferences.isIgnoreStringLiterals();
		51
		52	ISpellDictionary toRemove= null;
43	try {	53	try {
44	checker.addListener(listener);	54	checker.addListener(listener);
		55
		56	IDocCommentOwner owner= null;
		57	if(document instanceof IDocumentExtension3) {
		58	IDocumentPartitioner partitioner= ((IDocumentExtension3)document).getDocumentPartitioner(ICPartitions.C_PARTITIONING);
		59	if(partitioner instanceof FastCPartitioner) {
		60	owner= ((FastCPartitioner)partitioner).getDocCommentOwner();
		61	}
		62	}
		63
45	try {	64	try {
46	for (int i= 0; i < regions.length; i++) {	65	for (int i= 0; i < regions.length; i++) {
47	IRegion region= regions[i];	66	IRegion region= regions[i];
Lines 57-62 Link Here
57	if (isIgnoringStringLiterals && type.equals(ICPartitions.C_STRING))	76	if (isIgnoringStringLiterals && type.equals(ICPartitions.C_STRING))
58	continue;	77	continue;
59		78
		79	if(owner!=null) {
		80	IDocCommentDictionary dict= null;
		81
		82	if (type.equals(ICPartitions.C_MULTI_LINE_DOC_COMMENT)) {
		83	dict= owner.getMultilineConfiguration().getSpellingDictionary();
		84	} else if (type.equals(ICPartitions.C_SINGLE_LINE_DOC_COMMENT)) {
		85	dict= owner.getSinglelineConfiguration().getSpellingDictionary();
		86	}
		87
		88	if(dict instanceof IDocCommentSimpleDictionary) {
		89	ISpellDictionary sd= new DocCommentSpellDictionary((IDocCommentSimpleDictionary)dict);
		90	checker.addDictionary(sd);
		91	toRemove= sd;
		92	}
		93	}
		94
60	if (type.equals(ICPartitions.C_PREPROCESSOR)) {	95	if (type.equals(ICPartitions.C_PREPROCESSOR)) {
61	CTextTools textTools = CUIPlugin.getDefault().getTextTools();	96	CTextTools textTools = CUIPlugin.getDefault().getTextTools();
62	RuleBasedScanner scanner = textTools.getCppPreprocessorScanner();	97	RuleBasedScanner scanner = textTools.getCppPreprocessorScanner();
Lines 101-112 Link Here
101	!type.equals(ICPartitions.C_CHARACTER)) {	136	!type.equals(ICPartitions.C_CHARACTER)) {
102	checker.execute(new SpellCheckIterator(document, partition, checker.getLocale()));	137	checker.execute(new SpellCheckIterator(document, partition, checker.getLocale()));
103	}	138	}
		139
		140	if(toRemove != null) {
		141	checker.removeDictionary(toRemove);
		142	toRemove= null;
		143	}
104	}	144	}
105	}	145	}
106	} catch (BadLocationException x) {	146	} catch (BadLocationException x) {
107	CUIPlugin.getDefault().log(x);	147	CUIPlugin.getDefault().log(x);
108	}	148	}
109	} finally {	149	} finally {
		150	if(toRemove!=null)
		151	checker.removeDictionary(toRemove);
110	checker.removeListener(listener);	152	checker.removeListener(listener);
111	}	153	}
112	}	154	}

Lines 11-25 Link Here

(-)src/org/eclipse/cdt/internal/ui/editor/CDocumentSetupParticipant.java (-5 / +16 lines)
11		11
12	package org.eclipse.cdt.internal.ui.editor;	12	package org.eclipse.cdt.internal.ui.editor;
13		13
14	import org.eclipse.cdt.internal.ui.text.CTextTools;
15	import org.eclipse.cdt.ui.CUIPlugin;
16	import org.eclipse.core.filebuffers.IDocumentSetupParticipant;	14	import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
		15	import org.eclipse.core.filebuffers.IDocumentSetupParticipantExtension;
		16	import org.eclipse.core.filebuffers.LocationKind;
		17	import org.eclipse.core.runtime.IPath;
17	import org.eclipse.jface.text.IDocument;	18	import org.eclipse.jface.text.IDocument;
18		19
		20	import org.eclipse.cdt.ui.CUIPlugin;
		21
		22	import org.eclipse.cdt.internal.ui.text.CTextTools;
		23
19	/**	24	/**
20	* CDocumentSetupParticipant	25	* CDocumentSetupParticipant
21	*/	26	*/
22	public class CDocumentSetupParticipant implements IDocumentSetupParticipant {	27	public class CDocumentSetupParticipant implements IDocumentSetupParticipant, IDocumentSetupParticipantExtension {
23	/**	28	/**
24	*	29	*
25	*/	30	*/
Lines 30-37 Link Here
30	* @see org.eclipse.core.filebuffers.IDocumentSetupParticipant#setup(org.eclipse.jface.text.IDocument)	35	* @see org.eclipse.core.filebuffers.IDocumentSetupParticipant#setup(org.eclipse.jface.text.IDocument)
31	*/	36	*/
32	public void setup(IDocument document) {	37	public void setup(IDocument document) {
		38	setup(document, null, null);
		39	}
		40
		41	/*
		42	* @see org.eclipse.core.filebuffers.IDocumentSetupParticipantExtension#setup(org.eclipse.jface.text.IDocument, org.eclipse.core.runtime.IPath, org.eclipse.core.filebuffers.LocationKind)
		43	*/
		44	public void setup(IDocument document, IPath location, LocationKind locationKind) {
33	CTextTools tools= CUIPlugin.getDefault().getTextTools();	45	CTextTools tools= CUIPlugin.getDefault().getTextTools();
34	tools.setupCDocument(document);	46	tools.setupCDocument(document, location, locationKind);
35	}	47	}
36
37	}	48	}

Lines 110-116 Link Here

(-)src/org/eclipse/cdt/internal/ui/preferences/formatter/CPreview.java (-1 / +1 lines)
110	CTextTools tools= CUIPlugin.getDefault().getTextTools();	110	CTextTools tools= CUIPlugin.getDefault().getTextTools();
111	fPreviewDocument= new Document();	111	fPreviewDocument= new Document();
112	fWorkingValues= workingValues;	112	fWorkingValues= workingValues;
113	tools.setupCDocumentPartitioner( fPreviewDocument, ICPartitions.C_PARTITIONING);	113	tools.setupCDocumentPartitioner(fPreviewDocument, ICPartitions.C_PARTITIONING, null);
114		114
115	PreferenceStore prioritizedSettings= new PreferenceStore();	115	PreferenceStore prioritizedSettings= new PreferenceStore();
116		116




	String C_PARTITIONING= "___c_partitioning";  //$NON-NLS-1$

	/**
	 * The identifier of the single-line comment partition content type.
	 */
	String C_SINGLE_LINE_COMMENT= "__c_singleline_comment"; //$NON-NLS-1$


	 * The identifier of the C preprocessor partition content type.
	 */
	String C_PREPROCESSOR= "__c_preprocessor";  //$NON-NLS-1$
	
	/**
	 * The identifier of the single-line documentation tool comment partition content type.
	 */
	String C_SINGLE_LINE_DOC_COMMENT= "__c_singleline_doc_comment"; //$NON-NLS-1$

	/**
	 * The identifier multi-line comment documentation tool partition content type.
	 */
	String C_MULTI_LINE_DOC_COMMENT= "__c_multiline_doc_comment"; //$NON-NLS-1$
	
	/**
	 * 
	 * @since 5.0
	 */
	String[] ALL_CPARTITIONS= {
			ICPartitions.C_MULTI_LINE_COMMENT,
			ICPartitions.C_SINGLE_LINE_COMMENT,
			ICPartitions.C_STRING,
			ICPartitions.C_CHARACTER,
			ICPartitions.C_PREPROCESSOR,
			ICPartitions.C_SINGLE_LINE_DOC_COMMENT,
			ICPartitions.C_MULTI_LINE_DOC_COMMENT
	};
}

Lines 1-5 Link Here

(-)src/org/eclipse/cdt/ui/newui/Page_head_general.java (-2 / +57 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2007 Intel Corporation and others	2	* Copyright (c) 2005, 2008 Intel Corporation and others
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-22 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Intel Corporation - initial API and implementation	9	* Intel Corporation - initial API and implementation
		10	* Andrew Ferguson (Symbian)
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.ui.newui;	12	package org.eclipse.cdt.ui.newui;
12		13
		14	import org.eclipse.core.resources.IProject;
		15	import org.eclipse.core.runtime.CoreException;
		16	import org.eclipse.core.runtime.IAdaptable;
		17	import org.eclipse.core.runtime.NullProgressMonitor;
		18	import org.eclipse.core.runtime.Preferences;
13	import org.eclipse.swt.widgets.Composite;	19	import org.eclipse.swt.widgets.Composite;
14	import org.eclipse.swt.widgets.Control;	20	import org.eclipse.swt.widgets.Control;
15	import org.eclipse.ui.dialogs.PropertyPage;	21	import org.eclipse.ui.dialogs.PropertyPage;
16		22
17	public class Page_head_general extends PropertyPage {	23	import org.eclipse.cdt.core.CCorePlugin;
		24	import org.eclipse.cdt.ui.dialogs.DocCommentOwnerBlock;
		25	import org.eclipse.cdt.ui.dialogs.ICOptionContainer;
		26
		27	public class Page_head_general extends PropertyPage implements ICOptionContainer {
		28	private DocCommentOwnerBlock fDocBlock;
		29	private boolean isProjectLevel;
		30
18	protected Control createContents(Composite parent) {	31	protected Control createContents(Composite parent) {
		32	isProjectLevel= getElement() instanceof IProject;
		33	if(isProjectLevel) {
		34	fDocBlock= new DocCommentOwnerBlock();
		35	fDocBlock.setContainer(this);
		36	fDocBlock.createControl(parent);
		37	}
19	noDefaultAndApplyButton();	38	noDefaultAndApplyButton();
20	return parent;	39	return parent;
21	}	40	}
		41
		42	protected void performDefaults() {
		43	if(isProjectLevel) {
		44	fDocBlock.performDefaults();
		45	}
		46	super.performDefaults();
		47	}
		48
		49	public boolean performOk() {
		50	if(isProjectLevel) {
		51	try {
		52	fDocBlock.performApply(new NullProgressMonitor());
		53	} catch(CoreException ce) {
		54	CCorePlugin.log(ce);
		55	}
		56	}
		57	return true;
		58	}
		59
		60	public IProject getProject(){
		61	IProject project= null;
		62	IAdaptable elem = getElement();
		63	if (elem instanceof IProject) {
		64	project= (IProject) elem;
		65	} else if (elem != null) {
		66	project= (IProject) elem.getAdapter(IProject.class);
		67	}
		68	return project;
		69	}
		70
		71	public Preferences getPreferences() {
		72	throw new UnsupportedOperationException();
		73	}
		74
		75	public void updateContainer() {
		76	}
22	}	77	}

Lines 115-120 Link Here

(-)schema/completionProposalComputer.exsd (+4 lines)
115	</enumeration>	115	</enumeration>
116	<enumeration value="__c_preprocessor">	116	<enumeration value="__c_preprocessor">
117	</enumeration>	117	</enumeration>
		118	<enumeration value="__c_multiline_doc_comment">
		119	</enumeration>
		120	<enumeration value="__c_singleline_doc_comment">
		121	</enumeration>
118	</restriction>	122	</restriction>
119	</simpleType>	123	</simpleType>
120	</attribute>	124	</attribute>




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools.generic;

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

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.TextUtilities;

import org.eclipse.cdt.ui.text.ICPartitions;
import org.eclipse.cdt.ui.text.contentassist.ContentAssistInvocationContext;
import org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer;

import org.eclipse.cdt.internal.ui.text.contentassist.CCompletionProposal;

/**
 * CompletionProposalComputer based on a specified set of GenericTag objects.
 */
public class GenericTagCompletionProposalComputer implements ICompletionProposalComputer {
	char[] tagMarkers;
	
	GenericDocTag[] tags;
	
	public GenericTagCompletionProposalComputer(GenericDocTag[] tags) {
		this.tags= tags;
		this.tagMarkers= new char[] {'@','\\'};
	}
	
	protected boolean isTagMarker(char c) {
		for(int i=0; i<tagMarkers.length; i++)
			if(c == tagMarkers[i])
				return true;
		return false;
	}
	
	
	public List computeCompletionProposals(ContentAssistInvocationContext context, IProgressMonitor monitor) {
		IDocument doc= context.getDocument();
		int ivcOffset= context.getInvocationOffset();
		try {
			ITypedRegion tr= TextUtilities.getPartition(doc, ICPartitions.C_PARTITIONING, ivcOffset, false);
			int firstNonWS= ivcOffset;
			while(firstNonWS-1> tr.getOffset() && !Character.isWhitespace(doc.get(firstNonWS-1, 1).charAt(0)))
				firstNonWS--;
			String prefix= doc.get(firstNonWS, ivcOffset-firstNonWS);
			if(prefix.length()>0 && isTagMarker(prefix.charAt(0))) {
				List proposals= new ArrayList();
				char tagMarker= prefix.charAt(0);
				for(int i=0; i<tags.length; i++) {
					String tag= tags[i].getTagName();
					if(tag.toLowerCase().startsWith(prefix.substring(1).toLowerCase())) {						
						CCompletionProposal proposal= new CCompletionProposal(tagMarker+tag, ivcOffset-prefix.length(), prefix.length(), null, tagMarker+tag, 1, context.getViewer()); 
						String description= tags[i].getTagDescription();
						if(description!=null && !description.equals("")) { //$NON-NLS-1$
							proposal.setAdditionalProposalInfo(description);
						}
						proposals.add(proposal);
					}
				}
				return proposals;
			}
		} catch(BadLocationException ble) {
			// offset is zero, ignore
		}
		return new ArrayList();
	}

	/*
	 * @see org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer#computeContextInformation(org.eclipse.cdt.ui.text.contentassist.ContentAssistInvocationContext, org.eclipse.core.runtime.IProgressMonitor)
	 */
	public List computeContextInformation(ContentAssistInvocationContext context, IProgressMonitor monitor) {
		return Collections.EMPTY_LIST;
	}

	/*
	 * @see org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer#getErrorMessage()
	 */
	public String getErrorMessage() {
		return null;
	}

	/*
	 * @see org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer#sessionEnded()
	 */
	public void sessionEnded() {}
	
	/*
	 * @see org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer#sessionStarted()
	 */
	public void sessionStarted() {}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DocumentCommand;
import org.eclipse.jface.text.DocumentRewriteSession;
import org.eclipse.jface.text.DocumentRewriteSessionType;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentExtension4;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.ast.ASTVisitor;
import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTNodeLocation;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.model.CModelException;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.IWorkingCopyManager;
import org.eclipse.cdt.ui.text.ICPartitions;

/**
 * This class provides default behaviours for multi-line comment auto-editing.
 * 
 * This class is intended to be sub-classed.
 * 
 * @since 5.0
 */
public class DefaultMultilineCommentAutoEditStrategy implements IAutoEditStrategy {
	protected static final String MULTILINE_START = "/*"; //$NON-NLS-1$#
	protected static final String MULTILINE_MID = " * "; //$NON-NLS-1$
	protected static final String MULTILINE_END = "*/"; //$NON-NLS-1$
	
	public DefaultMultilineCommentAutoEditStrategy() {
	}
	
	/**
	 * @see org.eclipse.jface.text.IAutoEditStrategy#customizeDocumentCommand(org.eclipse.jface.text.IDocument, org.eclipse.jface.text.DocumentCommand)
	 */
	public void customizeDocumentCommand(IDocument doc, DocumentCommand cmd) {
		if(doc instanceof IDocumentExtension4) {
			IDocumentExtension4 ext4= (IDocumentExtension4) doc;
			DocumentRewriteSession drs= ext4.startRewriteSession(DocumentRewriteSessionType.UNRESTRICTED_SMALL);
			try {
				if (cmd.length == 0 && cmd.text != null && endsWithDelimiter(doc, cmd.text))
					customizeDocumentAfterNewLine(doc, cmd);
				else if ("/".equals(cmd.text)) { //$NON-NLS-1$
					customizeDocumentForMultilineCommentEnd(doc, cmd);
				}
			} finally {
				ext4.stopRewriteSession(drs);
			}
		}
	}
	
	/**
	 * This implements a rule that when in a multiline comment context typing a forward slash with
	 * one white space after the "*" will move eliminate the whitespace.
	 * @param doc
	 * @param command
	 */
	protected void customizeDocumentForMultilineCommentEnd(IDocument doc, DocumentCommand command) {
		if (command.offset < 2 || doc.getLength() == 0) {
			return;
		}
		try {
			if ("* ".equals(doc.get(command.offset - 2, 2))) { //$NON-NLS-1$
				// modify document command
				command.length++;
				command.offset--;
			}					
		} catch (BadLocationException excp) {
			// stop work
		}
	}
	
	/**
	 * Copies the indentation of the previous line and adds a star.
	 * If the comment just started on this line adds also a blank.
	 *
	 * @param doc the document to work on
	 * @param c the command to deal with
	 */
	public void customizeDocumentAfterNewLine(IDocument doc, final DocumentCommand c) {
		int offset= c.offset;
		if (offset == -1 || doc.getLength() == 0)
			return;
		
		final StringBuffer buf= new StringBuffer(c.text);
		try {
			// find start of line
			IRegion line= doc.getLineInformationOfOffset(c.offset);
			int lineStart= line.getOffset();
			int firstNonWS= findEndOfWhiteSpaceAt(doc, lineStart, c.offset);

			IRegion prefix= findPrefixRange(doc, line);
			String indentation= doc.get(prefix.getOffset(), prefix.getLength());
			int lengthToAdd= Math.min(offset - prefix.getOffset(), prefix.getLength());
			buf.append(indentation.substring(0, lengthToAdd));
			
			boolean commentAtStart= firstNonWS < c.offset && doc.getChar(firstNonWS) == '/'; 
			if (commentAtStart) {
				// comment started on this line
				buf.append(MULTILINE_MID);
			}

			c.shiftsCaret= false;
			c.caretOffset= c.offset + buf.length();

			if(commentAtStart && shouldCloseMultiline(doc, c.offset)) {
				try {
					doc.replace(c.offset, 0, indentation+" "+MULTILINE_END); // close the comment in order to parse //$NON-NLS-1$
					buf.append("\n"); //$NON-NLS-1$
					
					// as we are autoclosing, the comment becomes eligable for auto-doc'ing
					IASTDeclaration dec= findFollowingDeclaration(getAST(), offset);
					if(dec!=null) {
						ITypedRegion partition= TextUtilities.getPartition(doc, ICPartitions.C_PARTITIONING /* this! */, offset, false);
						StringBuffer content= customizeAfterNewLineForDeclaration(doc, dec, partition);
						buf.append(indent(content, indentation + MULTILINE_MID));
					}

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

			c.text= buf.toString();

		} catch (BadLocationException excp) {
			// stop work
		}	
	}

	protected StringBuffer customizeAfterNewLineForDeclaration(IDocument doc, IASTDeclaration dec, ITypedRegion region) {
		return new StringBuffer();
	}
	
	/*
	 * Utilities
	 */
	
	/**
	 * Locates the {@link IASTDeclaration} most immediately following the specified offset
	 * @param unit the translation unit, or null (in which case the result will also be null)
	 * @param offset the offset to begin the search from
	 * @return the {@link IASTDeclaration} most immediately following the specified offset, or null if there
	 * is no {@link IASTDeclaration}
	 */
	public static IASTDeclaration findFollowingDeclaration(IASTTranslationUnit unit, final int offset) {
		final IASTDeclaration[] dec= new IASTDeclaration[1];
		final ASTVisitor av= new ASTVisitor() {
			{
				shouldVisitTranslationUnit= true;
				shouldVisitDeclarations= true;
			}
			
			/**
			 * Holds the 
			 */
			IASTDeclaration stopWhenLeaving;
			
			public int visit(IASTDeclaration declaration) {
				IASTNodeLocation[] locs= declaration.getNodeLocations();
				if(locs.length>0) {
					for(int i=0; i<locs.length; i++) {
						IASTNodeLocation loc= locs[i];

						int candidateOffset= loc.getNodeOffset();
						int candidateEndOffset= candidateOffset+loc.getNodeLength();
						
						if(offset <= candidateOffset) {
							dec[0]= declaration;
							return PROCESS_ABORT;
						}
						
						boolean candidateEnclosesOffset= (offset >= candidateOffset) && (offset < candidateEndOffset);
						if(candidateEnclosesOffset) {
							stopWhenLeaving= declaration;
						}
					}
				}
				return PROCESS_CONTINUE;
			}
			public int leave(IASTDeclaration declaration) {
				if(declaration==stopWhenLeaving) 
					return PROCESS_ABORT;
				return PROCESS_CONTINUE;
			}
		};
		
		if(unit!=null) {
			unit.accept(av);
		}
		return dec[0];
	}
	
	/**
	 * @return the ast unit for the active editor, or null if there is no active editor, or
	 * the ast could not be obtained.
	 */
	public static IASTTranslationUnit getAST() {
		final ITranslationUnit unit= getTranslationUnit();
		try {
			if(unit!=null) {
				IASTTranslationUnit ast= unit.getAST(null, ITranslationUnit.AST_SKIP_ALL_HEADERS);
				return ast;
			}
		} catch(CModelException ce) {
			CCorePlugin.log(ce);
		} catch(CoreException ce) {
			CCorePlugin.log(ce);
		}
		return null;
	}

	/**
	 * Assuming the offset is within a multi-line comment, returns a guess as to
	 * whether the enclosing multi-line comment is a new comment. The result is undefined if
	 * the offset does not occur within a multi-line comment.
	 *
	 * @param document the document
	 * @param offset the offset
	 * @return <code>true</code> if the comment should be closed, <code>false</code> if not
	 */
	/*
	 * Adapted from JDT
	 */
	public boolean shouldCloseMultiline(IDocument document, int offset) {
		try {
			IRegion line= document.getLineInformationOfOffset(offset);
			ITypedRegion partition= TextUtilities.getPartition(document, ICPartitions.C_PARTITIONING, offset, false);
			int partitionEnd= partition.getOffset() + partition.getLength();
			if (line.getOffset() >= partitionEnd)
				return false;

			String comment= document.get(partition.getOffset(), partition.getLength());
			if (comment.indexOf(MULTILINE_START, offset - partition.getOffset()) != -1) 
				return true; // enclosed another comment -> probably a new comment

			if (document.getLength() == partitionEnd) {
				return !comment.endsWith(MULTILINE_END);
			}
			
			return false;

		} catch (BadLocationException e) {
			return false;
		}
	}

	/**
	 * @return the ITranslationUnit for the active editor, or null if no active
	 * editor could be found.
	 */
	/*
	 * Cloned from JDT
	 */
	protected static ITranslationUnit getTranslationUnit() {
		IWorkbenchWindow window= PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if (window == null)
			return null;

		IWorkbenchPage page= window.getActivePage();
		if (page == null)
			return null;

		IEditorPart editor= page.getActiveEditor();
		if (editor == null)
			return null;

		IWorkingCopyManager manager= CUIPlugin.getDefault().getWorkingCopyManager();
		ITranslationUnit unit= manager.getWorkingCopy(editor.getEditorInput());
		if (unit == null)
			return null;

		return unit;
	}
	
	/**
	 * Returns a new buffer with the specified indent string inserted at the beginning
	 * of each line in the specified input buffer
	 * @param buffer
	 * @param indent
	 */
	protected static final StringBuffer indent(StringBuffer buffer, String indent) {
		StringBuffer result= new StringBuffer();
		BufferedReader br= new BufferedReader(new StringReader(buffer.toString()));
		try {
			for(String line= br.readLine(); line!=null; line= br.readLine()) {
				result.append(indent + line + "\n"); //$NON-NLS-1$
			}
		} catch(IOException ioe) {
			throw new AssertionError(); // we can't get IO errors from a string backed reader
		}
		return result;
	}
	
	/**
	 * Returns the offset of the first non-whitespace character in the specified document, searching
	 * right/downward from the specified start offset up to the specified end offset. If there is
	 * no nonwhitespace then the end offset is returned.
	 * @param document
	 * @param offset
	 * @param end
	 * @throws BadLocationException
	 */
	protected static int findEndOfWhiteSpaceAt(IDocument document, int offset, int end) throws BadLocationException {
		while (offset < end) {
			char c= document.getChar(offset);
			if (c != ' ' && c != '\t') {
				return offset;
			}
			offset++;
		}
		return end;
	}
	
	/**
	 * Returns the range of the Javadoc prefix on the given line in
	 * <code>document</code>. The prefix greedily matches the following regex
	 * pattern: <code>\w*\*\w*</code>, that is, any number of whitespace
	 * characters, followed by an asterix ('*'), followed by any number of
	 * whitespace characters.
	 *
	 * @param document the document to which <code>line</code> refers
	 * @param line the line from which to extract the prefix range
	 * @return an <code>IRegion</code> describing the range of the prefix on
	 *         the given line
	 * @throws BadLocationException if accessing the document fails
	 */
	protected static IRegion findPrefixRange(IDocument document, IRegion line) throws BadLocationException {
		int lineOffset= line.getOffset();
		int lineEnd= lineOffset + line.getLength();
		int indentEnd= findEndOfWhiteSpaceAt(document, lineOffset, lineEnd);
		if (indentEnd < lineEnd && document.getChar(indentEnd) == '*') {
			indentEnd++;
			while (indentEnd < lineEnd && document.getChar(indentEnd) != ' ')
				indentEnd++;
			while (indentEnd < lineEnd && document.getChar(indentEnd) == ' ')
				indentEnd++;
		}
		return new Region(lineOffset, indentEnd - lineOffset);
	}
	
	/**
	 * Returns whether the text ends with one of the specified IDocument object's
	 * legal line delimiters.
	 */
	protected static boolean endsWithDelimiter(IDocument d, String txt) {
		String[] delimiters= d.getLegalLineDelimiters();
		for (int i= 0; i < delimiters.length; i++) {
			if (txt.endsWith(delimiters[i]))
				return true;
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text;

import org.eclipse.jface.text.rules.ITokenScanner;
import org.eclipse.cdt.ui.IPropertyChangeParticipant;

/**
 * Interface for CDT Scanners. Scanners used in CDT must additionally be
 * IPropertyChangeParticipant's.
 *
 * @since 5.0
 */
public interface ICTokenScanner extends ITokenScanner, IPropertyChangeParticipant {
}




package org.eclipse.cdt.internal.ui.text.doctools.docpp;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.generic.AbstractGenericTagDocCommentViewerConfiguration;
import org.eclipse.cdt.ui.text.doctools.generic.GenericDocTag;

public class DocppSingleConfiguration extends AbstractGenericTagDocCommentViewerConfiguration {
	GenericDocTag[] tags;
	
	public DocppSingleConfiguration() {
		super(DocppHelper.getDocPPTags(), new char[] {'@','\\'}, DocppHelper.DOCPP_SINGLE_TOKEN, DocppHelper.DOCPP_TAG_RECOGNIZED);
	}
		
	public IAutoEditStrategy createAutoEditStrategy() {
		return new DefaultIndentLineAutoEditStrategy();
	}
	
	public boolean isDocumentationComment(IDocument doc, int offset, int length) {
		try {
			if(offset+2 < doc.getLength()) {
				char c= doc.getChar(offset+2);
				if(c == '@') {
					if(offset + 3 < doc.getLength()) {
						char d= doc.getChar(offset+3); 
						return d == '{' || d == '}';
					}
				}
				return c == '/';
			}
		} catch(BadLocationException ble) {
			CUIPlugin.getDefault().log(ble);
		}
		return false;
	}
}




package org.eclipse.cdt.internal.ui.text.doctools.doxygen;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.generic.AbstractGenericTagDocCommentViewerConfiguration;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;

public class DoxygenMultilineConfiguration extends AbstractGenericTagDocCommentViewerConfiguration {
	
	public DoxygenMultilineConfiguration() {
		super(DoxygenHelper.getDoxygenTags(), new char[] {'@','\\'}, DoxygenHelper.DOXYGEN_MULTI_TOKEN, DoxygenHelper.DOXYGEN_TAG_RECOGNIZED);
	}
	
	public IAutoEditStrategy createAutoEditStrategy() {
		return new DoxygenMultilineAutoEditStrategy();
	}
	
	public boolean isDocumentationComment(IDocument doc, int offset, int length) {
		try {
			if(offset+2 < doc.getLength()) {
				char c= doc.getChar(offset+2);
				return c == '*' || c == '!';
			}
		} catch(BadLocationException ble) {
			CUIPlugin.getDefault().log(ble);
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;

public final class NullDocCommentOwner extends DocCommentOwner {
	private static final String ID = "org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentOwner"; //$NON-NLS-1$
	public static final IDocCommentOwner INSTANCE= new NullDocCommentOwner();
	private NullDocCommentOwner() {
		super(
			ID,
			Messages.NullDocCommentOwner_Name,
			NullDocCommentViewerConfiguration.INSTANCE,
			NullDocCommentViewerConfiguration.INSTANCE
			);
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
import org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration;


public class DocCommentSinglelineProposalComputer extends AbstractDocCommentProposalComputer {
	protected IDocCommentViewerConfiguration getConfiguration(IDocCommentOwner owner) {
		return owner.getSinglelineConfiguration();
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text;

/**
 * A means of obtaining ITokenStore objects
 * @since 5.0
 */
public interface ITokenStoreFactory {
	/**
	 * @param propertyColorNames
	 * @return a token store object initialized with the specified propertyColorNames
	 */
	public ITokenStore createTokenStore(String[] propertyColorNames);
}




package org.eclipse.cdt.internal.ui.text.doctools.docpp;

import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITypedRegion;

import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTFunctionDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition;
import org.eclipse.cdt.core.dom.ast.IASTParameterDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTStandardFunctionDeclarator;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateDeclaration;
import org.eclipse.cdt.ui.text.doctools.DefaultMultilineCommentAutoEditStrategy;

/**
 * {@link IAutoEditStrategy} for adding Docpp tags for comments.
 */
public class DocppMultilineAutoEditStrategy extends DefaultMultilineCommentAutoEditStrategy {
	private static final String PARAM = "@param "; //$NON-NLS-1$
	private static final String RETURN = "@return\n"; //$NON-NLS-1$

	protected StringBuffer paramTags(IASTParameterDeclaration[] decls) {
		StringBuffer result= new StringBuffer();
		for(int i=0; i<decls.length; i++) {
			IASTDeclarator dtor= decls[i].getDeclarator();
			result.append(PARAM+dtor.getName()+"\n"); //$NON-NLS-1$
		}
		return result;
	}
	
	protected StringBuffer returnTag() {
		return new StringBuffer(RETURN);
	}
	
	protected IASTParameterDeclaration[] getParameterDecls(IASTFunctionDefinition def) {
		IASTParameterDeclaration[] result;
		IASTFunctionDeclarator decl= def.getDeclarator();
		if (decl instanceof IASTStandardFunctionDeclarator) {
			IASTStandardFunctionDeclarator standardFunctionDecl= (IASTStandardFunctionDeclarator)decl;
			result= standardFunctionDecl.getParameters();
		} else /*if (def instanceof ICASTKnRFunctionDeclarator) {
			ICASTKnRFunctionDeclarator knrDeclarator= (ICASTKnRFunctionDeclarator)decl;
			result= knrDeclarator.getParameterDeclarations();
		} else */{
			result= new IASTParameterDeclaration[0];
		}
		return result;
	}
	
	public StringBuffer customizeAfterNewLineForDeclaration(IDocument doc, IASTDeclaration dec, ITypedRegion partition) {
		StringBuffer result= new StringBuffer();
		
		while(dec instanceof ICPPASTTemplateDeclaration) /* if? */
			dec= ((ICPPASTTemplateDeclaration)dec).getDeclaration(); 
		
		if(dec instanceof IASTFunctionDefinition) {
			IASTFunctionDefinition fd= (IASTFunctionDefinition) dec;
			result.append(paramTags(getParameterDecls(fd)));
			
			IASTDeclSpecifier ds= fd.getDeclSpecifier();
			boolean hasReturn= true;
			if(ds instanceof IASTSimpleDeclSpecifier) {
				IASTSimpleDeclSpecifier sds= (IASTSimpleDeclSpecifier) ds;
				if(sds.getType()==IASTSimpleDeclSpecifier.t_void) {
					hasReturn= false;
				}
			}
			if(hasReturn) {
				result.append(returnTag());
			}
			
			return result;
		}
		
		return new StringBuffer();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools;

/**
 * This interface is a simplified means of obtaining spelling support. 
 * @since 5.0
 */
public interface IDocCommentSimpleDictionary extends IDocCommentDictionary {
	/**
	 * @return an array of words that should be regarded as correct. These
	 * words will be considered in addition to those provided by existing dictionaries.
	 */
	public String[] getAdditionalWords();
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import org.eclipse.osgi.util.NLS;

public class Messages extends NLS {
	private static final String BUNDLE_NAME = "org.eclipse.cdt.internal.ui.text.doctools.messages"; //$NON-NLS-1$
	public static String EditorReopener_ReopenJobComplete;
	public static String EditorReopener_ReopenJobStart;
	public static String EditorReopener_ShouldSave_Message;
	public static String EditorReopener_ShouldSave_Title;
	public static String NullDocCommentOwner_Name;
	static {
		// initialize resource bundle
		NLS.initializeMessages(BUNDLE_NAME, Messages.class);
	}

	private Messages() {
	}
}




package org.eclipse.cdt.internal.ui.text.doctools.doxygen;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.generic.AbstractGenericTagDocCommentViewerConfiguration;
import org.eclipse.cdt.ui.text.doctools.generic.GenericDocTag;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;

public class DoxygenSingleConfiguration extends AbstractGenericTagDocCommentViewerConfiguration {
	GenericDocTag[] tags;
	
	public DoxygenSingleConfiguration() {
		super(DoxygenHelper.getDoxygenTags(), new char[] {'@','\\'}, DoxygenHelper.DOXYGEN_SINGLE_TOKEN, DoxygenHelper.DOXYGEN_TAG_RECOGNIZED);
	}
		
	public IAutoEditStrategy createAutoEditStrategy() {
		return new DefaultIndentLineAutoEditStrategy();
	}
	
	public boolean isDocumentationComment(IDocument doc, int offset, int length) {
		try {
			if(offset+2 < doc.getLength()) {
				char c= doc.getChar(offset+2);
				return c == '/' || c == '!';
			}
		} catch(BadLocationException ble) {
			CUIPlugin.getDefault().log(ble);
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.osgi.service.prefs.Preferences;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
import org.eclipse.cdt.ui.text.doctools.IDocCommentOwnershipListener;
import org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration;

/**
 * This class manages which IDocCommentOwner's are available in the run-time, and how they map to resources
 * in projects.
 */
public class DocCommentOwnerManager {
	/** Constants for attributes/elements from the DocCommentOwner extension point */
	private static final String ELEMENT_OWNER = "owner"; //$NON-NLS-1$
	private static final String ATTRKEY_OWNER_ID = "id"; //$NON-NLS-1$
	private static final String ATTRKEY_OWNER_NAME = "name"; //$NON-NLS-1$
	private static final String ATTRKEY_OWNER_SINGLELINE = "singleline"; //$NON-NLS-1$
	private static final String ATTRKEY_OWNER_MULTILINE = "multiline"; //$NON-NLS-1$

	private static final String QUALIFIER= CCorePlugin.PLUGIN_ID;
	private static final String WORKSPACE_DOC_TOOL_NODE= "doctool"; //$NON-NLS-1$
	private static final String PREFKEY_WORKSPACE_DEFAULT= "workspace.default"; //$NON-NLS-1$
	
	private static DocCommentOwnerManager singleton;

	public static DocCommentOwnerManager getInstance() {
		return singleton==null ? singleton= new DocCommentOwnerManager() : singleton;
	}

	private Map/*<String, IDocCommentOwner>*/ fOwners;
	private IDocCommentOwner fWorkspaceOwner;
	private Map prj2map= new HashMap();
	private static List fListeners;

	private DocCommentOwnerManager() {
		fOwners= getCommentOwnerExtensions();
		fListeners= new ArrayList();

		Preferences prefs= new InstanceScope().getNode(QUALIFIER).node(WORKSPACE_DOC_TOOL_NODE);
		String id= prefs.get(PREFKEY_WORKSPACE_DEFAULT, NullDocCommentOwner.INSTANCE.getID());
		fWorkspaceOwner= getOwner(id);
		if(fWorkspaceOwner == null) {
			// this could occur if a plug-in is no longer available
			fWorkspaceOwner= NullDocCommentOwner.INSTANCE;
		}
	}

	/**
	 * @param project a non-null project
	 * @return whether the specified project defines any documentation owner association 
	 */
	public boolean projectDefinesOwnership(IProject project) {
		return !getProjectMap(project).isEmpty();
	}

	/**
	 * @param owner the non-null doc-comment owner
	 */
	public void setWorkspaceCommentOwner(IDocCommentOwner owner) {
		if(owner == null)
			throw new IllegalArgumentException();
		IDocCommentOwner old= fWorkspaceOwner;
		fWorkspaceOwner= owner;

		Preferences prefs= new InstanceScope().getNode(QUALIFIER).node(WORKSPACE_DOC_TOOL_NODE);
		prefs.put(PREFKEY_WORKSPACE_DEFAULT, owner.getID());

		fireWorkspaceOwnershipChanged(old, fWorkspaceOwner);
	}

	/**
	 * @return the doc comment owner associated with the workspace. If non
	 * is set, the {@link NullDocCommentOwner} is returned.
	 */
	public IDocCommentOwner getWorkspaceCommentOwner() {
		return fWorkspaceOwner;
	}

	/**
	 * 
	 * @param resource May be null.
	 * @return a non-null IDocCommentOwner. If the resource was null, the {@link NullDocCommentOwner} is returned.
	 */
	public IDocCommentOwner getCommentOwner(IResource resource) {
		if(resource==null)
			return NullDocCommentOwner.INSTANCE;

		if(ResourcesPlugin.getWorkspace().getRoot().equals(resource))
			return getWorkspaceCommentOwner();

		ProjectMap pm= getProjectMap(resource);
		String ownerID= pm.getOwnerID(resource);
		IDocCommentOwner result= getOwner(ownerID);
		return result == null ? fWorkspaceOwner : result;
	}

	/**
	 * @param id
	 * @return the {@link IDocCommentOwner} with the specified id, or null
	 */
	public IDocCommentOwner getOwner(String id) {
		if(NullDocCommentOwner.INSTANCE.getID().equals(id)) {
			return NullDocCommentOwner.INSTANCE;
		}
		return (IDocCommentOwner) fOwners.get(id);
	}

	/**
	 * @param resource a non-null resource to map a comment owner to
	 * @param owner the new owner to assign, or null to inherit the parent's mapping
	 * @param removeSubMappings if the resource is an {@link IContainer}, then remove any mappings
	 * children have. <em>This is currently unimplemented.</em>
	 */
	/*
	 * Note - this implementation currently ignores removeSubMappings.
	 */
	public void setCommentOwner(IResource resource, IDocCommentOwner owner, boolean removeSubMappings) {
		Assert.isNotNull(resource);

		if(ResourcesPlugin.getWorkspace().getRoot().equals(resource)) {
			setWorkspaceCommentOwner(owner);
			return;
		}

		ProjectMap pm= getProjectMap(resource);
		IDocCommentOwner old= getCommentOwner(resource);
		pm.setCommentOwner(resource, owner);
		IDocCommentOwner n3w= getCommentOwner(resource);
		fireOwnershipChanged(resource, removeSubMappings, old, n3w);
	}

	/**
	 * @return any comment owners registered against the extension point. This does not include
	 * the null comment processor.
	 */
	public IDocCommentOwner[] getRegisteredOwners() {
		return (IDocCommentOwner[]) fOwners.values().toArray(new IDocCommentOwner[fOwners.values().size()]);
	}


	/**
	 * @param listener registers a listener for doc-comment ownership events
	 */
	public void addListener(IDocCommentOwnershipListener listener) {
		if(!fListeners.contains(listener)) {
			fListeners.add(listener);
		}
	}

	/**
	 * @param listener removes a listener from those registered for doc-comment ownership events
	 */
	public void removeListener(IDocCommentOwnershipListener listener) {
		fListeners.add(listener);
	}

	/*
	 * Utilities
	 */

	/**
	 * @param resource a non-null resource
	 * @return the cached (or newly obtained) ProjectMap for the resources
	 * associated project.
	 */
	private ProjectMap getProjectMap(IResource resource) {
		Assert.isNotNull(resource);
		IProject project= resource.getProject();

		if(!prj2map.containsKey(project)) {
			prj2map.put(project, new ProjectMap(project));
		}

		return (ProjectMap) prj2map.get(project);
	}

	/**
	 * @return a map of ID to {@link IDocCommentOwner} for comment owners registered
	 * via the DocCommentOwner extension point
	 */
	private static Map getCommentOwnerExtensions() {
		Map result= new HashMap();

		IExtensionRegistry registry = Platform.getExtensionRegistry();
		IExtensionPoint indexProviders = registry.getExtensionPoint(CUIPlugin.ID_COMMENT_OWNER);
		IExtension[] extensions = indexProviders.getExtensions();
		for(int i=0; i<extensions.length; i++) {
			IExtension extension = extensions[i];
			try {
				IConfigurationElement[] ce = extension.getConfigurationElements();
				for(int j=0; j<ce.length; j++) {
					if(ce[j].getName().equals(ELEMENT_OWNER)) { 
						IDocCommentViewerConfiguration multi = (IDocCommentViewerConfiguration) ce[j].createExecutableExtension(ATTRKEY_OWNER_MULTILINE);
						IDocCommentViewerConfiguration single = (IDocCommentViewerConfiguration) ce[j].createExecutableExtension(ATTRKEY_OWNER_SINGLELINE);
						String id= ce[j].getAttribute(ATTRKEY_OWNER_ID);
						String name= ce[j].getAttribute(ATTRKEY_OWNER_NAME);
						result.put(id, new DocCommentOwner(id, name, multi, single));						
					}
				}
			} catch(CoreException ce) {
				CCorePlugin.log(ce);
			}
		}

		return result;
	}

	private void fireOwnershipChanged(IResource resource, boolean recursive, IDocCommentOwner old, IDocCommentOwner n3w) {
		for(Iterator i= fListeners.iterator(); i.hasNext();) {
			((IDocCommentOwnershipListener)i.next()).ownershipChanged(resource, recursive, old, n3w);
		}
	}

	private void fireWorkspaceOwnershipChanged(IDocCommentOwner old, IDocCommentOwner n3w) {
		for(Iterator i= fListeners.iterator(); i.hasNext();) {
			((IDocCommentOwnershipListener)i.next()).workspaceOwnershipChanged(old, n3w);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.rules.IToken;

import org.eclipse.cdt.ui.IPropertyChangeParticipant;
import org.eclipse.cdt.ui.PreferenceConstants;

/**
 * An ITokenStore manages a set of tokens for a specified set of color property identifiers. Responsibilities include
 * <ul>
 * <li> Reacting to changes to preferences in a specified {@link IPreferenceStore}
 * <li> Managing whether further styles (bold, italic, strikethrough, underline) should be applied
 * <li> Coping with 
 * </ul>
 * 
 * ITokenStore assumes style preferences are stored under the following names
 * <p>
 * Preference color key + {@link PreferenceConstants#EDITOR_BOLD_SUFFIX} are used
 * to retrieve whether the token is rendered in bold.
 * </p>
 * <p>
 * Preference color key + {@link PreferenceConstants#EDITOR_ITALIC_SUFFIX} are used
 * to retrieve whether the token is rendered in italic.
 * </p>
 * <p>
 * Preference color key + {@link PreferenceConstants#EDITOR_STRIKETHROUGH_SUFFIX} are used
 * to retrieve whether the token is rendered in strikethrough.
 * </p>
 * <p>
 * Preference color key + {@link PreferenceConstants#EDITOR_UNDERLINE_SUFFIX} are used
 * to retrieve whether the token is rendered in underline.
 * </p>
 *
 * @see ITokenStoreFactory
 * @since 5.0
 */
public interface ITokenStore extends IPropertyChangeParticipant {
	/**
	 * Ensures any IToken objects that will be <em>or have been</em> returned are
     * initialized for display.
	 */
	void ensureTokensInitialised();
	
	/**
	 * @param property
	 * @return a token for the specified property. The Token may not be suitable for use if the
	 * current Display is null. Clients should call ITokenStoreFactory#ensureTokensInitialised() at the
	 * point of token use. // TODO - I've not yet determined when this is necessary
	 */
	IToken getToken(String property);
	
	/**
	 * @return The preference store used to read token styling preferences from.
	 */
	IPreferenceStore getPreferenceStore();
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import org.eclipse.core.runtime.Assert;

import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
import org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration;

/**
 * Internal implementation of IDocCommentOwner
 */
public class DocCommentOwner implements IDocCommentOwner {
	private final String id;
	private final String name;
	private final IDocCommentViewerConfiguration multi, single;
	
	public DocCommentOwner(String id, String name, IDocCommentViewerConfiguration multi, IDocCommentViewerConfiguration single) {
		Assert.isNotNull(id); Assert.isNotNull(name); Assert.isNotNull(multi); Assert.isNotNull(single);
		this.id= id;
		this.name= name;
		this.multi= multi;
		this.single= single;
	}
	
	/*
	 * @see org.eclipse.cdt.ui.text.ICCommentOwner#getID()
	 */
	public String getID() {
		return id;
	}
	
	/*
	 * @see org.eclipse.cdt.ui.text.ICCommentOwner#getName()
	 */
	public String getName() {
		return name;
	}
	
	/*
	 * @see org.eclipse.cdt.ui.text.ICCommentOwner#getMultilineConfiguration()
	 */
	public IDocCommentViewerConfiguration getMultilineConfiguration() {
		return multi;
	}
	
	/*
	 * @see org.eclipse.cdt.ui.text.ICCommentOwner#getSinglelineConfiguration()
	 */
	public IDocCommentViewerConfiguration getSinglelineConfiguration() {
		return single;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial Implementation
 *******************************************************************************/
package org.eclipse.cdt.ui;

import org.eclipse.jface.util.PropertyChangeEvent;

/**
 * Implemented by classes which can optionally participate in property
 * change events, and report whether an event would affect them without
 * adapting to it.
 * 
 * @since 5.0
 */
public interface IPropertyChangeParticipant {
	/**
	 * @param event
	 * @return true if the specified event will affect the participant's
	 * behaviour in a way it determines potential clients could act upon.
	 */
	public boolean affectsBehavior(PropertyChangeEvent event);
	
	/**
	 * Performs any necessary to adapt the participant to the specified event.
	 * @param event
	 */
	public void adaptToPreferenceChange(PropertyChangeEvent event);
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools;

/**
 * A comment owner provides {@link IDocCommentViewerConfiguration} ov
 * the CDT c/c++ editor.
 * 
 * This interface is not intended to be implemented externally to CDT.
 * @since 5.0
 */
public interface IDocCommentOwner {
	/**
	 * @return the non-null unique identifier for this comment owner. If contributed via the
	 * extension point, the ID corresponds to that in plugin.xml. 
	 */
	String getID();
	
	/**
	 * @return a non-null human-readable name for this comment owner. If contributed via plugin.xml
	 * this name can be localized using the plug-in externalization mechanism.
	 */
	String getName();

	/**
	 * @return a non-null {@link IDocCommentViewerConfiguration} suitable for a multi-line comment context
	 */
	IDocCommentViewerConfiguration getMultilineConfiguration();
	
	/**
	 * @return a non-null {@link IDocCommentViewerConfiguration} suitable for a single-line comment context
	 */
	IDocCommentViewerConfiguration getSinglelineConfiguration();
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools;

import org.eclipse.core.resources.IResource;


/**
 * Implemented by clients interested in documentation comment ownership change events. These are generated
 * when the association between resource or workspace and documentation comment owner is set.
 * @since 5.0
 */
public interface IDocCommentOwnershipListener {
	/**
	 * Called when document comment ownership has changed.
	 * @param resource
	 * @param submappingsRemoved
	 * @param old
	 * @param newOwner
	 */
	public void ownershipChanged(IResource resource, boolean submappingsRemoved, IDocCommentOwner old, IDocCommentOwner newOwner);
	
	/**
	 * TODO 
	 * @param old
	 * @param newOwner
	 */
	public void workspaceOwnershipChanged(IDocCommentOwner old, IDocCommentOwner newOwner);
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools.generic;

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

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.jface.text.rules.BufferedRuleBasedScanner;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.IWordDetector;
import org.eclipse.jface.text.rules.WordRule;
import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.cdt.ui.PreferenceConstants;
import org.eclipse.cdt.ui.text.ICTokenScanner;
import org.eclipse.cdt.ui.text.ITokenStore;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;
import org.eclipse.cdt.ui.text.TaskTagRule;

/**
 * ICTokenScanner which recognizes a specified set of tags, starting with a specified name
 */
public class GenericTagCommentScanner extends BufferedRuleBasedScanner implements ICTokenScanner {
	private TaskTagRule fTaskTagRule;
	private Preferences fCorePreferenceStore;
	private String fDefaultTokenProperty;
	private String fTagToken;
	
	private GenericDocTag[] fTags;
	private char[] fTagMarkers;
	private ITokenStore fTokenStore;
	
	private static String[] mkArray(String defaultTokenProperty, String tagToken) {
		return new String[] { defaultTokenProperty, tagToken, PreferenceConstants.EDITOR_TASK_TAG_COLOR };
	}
	
	/**
	 * @param tokenStoreFactory
	 * @param docToken
	 * @param tagToken
	 * @param tags
	 * @param tagMarkers
	 */
	public GenericTagCommentScanner(ITokenStoreFactory tokenStoreFactory, String docToken, String tagToken, GenericDocTag[] tags, char[] tagMarkers) {
		Assert.isNotNull(tags);
		fTags= tags;
		fTagMarkers= tagMarkers;
		fTagToken= tagToken;
		
		fTokenStore= tokenStoreFactory.createTokenStore(mkArray(docToken, tagToken));
		fCorePreferenceStore= null; // TODO
		fDefaultTokenProperty= docToken;
		
		setRules(createRules());
	}

	public IToken nextToken() {
		fTokenStore.ensureTokensInitialised();
		return super.nextToken();
	}
	
	protected IRule[] createRules() {
		List result= new ArrayList();

		class TagDetector implements IWordDetector {
			public boolean isWordStart(char c) {
				return c == '@' || c == '\\';
			}
			public boolean isWordPart(char c) {
				return c == '.' || Character.isJavaIdentifierPart(c);
			}
		}

		WordRule wr= new WordRule(new TagDetector(), fTokenStore.getToken(fDefaultTokenProperty));
		for(int i=0; i<fTags.length; i++) {
			String wd= fTags[i].getTagName();
			for(int j=0; j<fTagMarkers.length; j++) {
				wr.addWord(fTagMarkers[j]+wd, fTokenStore.getToken(fTagToken));
			}
		}
		result.add(wr);

		// Add rule for Task Tags.
		String taskWords= TaskTagRule.getTaskWords(fTokenStore.getPreferenceStore(), fCorePreferenceStore);
		fTaskTagRule= new TaskTagRule(fTokenStore.getToken(PreferenceConstants.EDITOR_TASK_TAG_COLOR), taskWords);
		result.add(fTaskTagRule);

		setDefaultReturnToken(fTokenStore.getToken(fDefaultTokenProperty));

		return (IRule[]) result.toArray(new IRule[result.size()]);
	}

	/*
	 * @see org.eclipse.cdt.internal.ui.text.AbstractJavaScanner#affectsBehavior(org.eclipse.jface.util.PropertyChangeEvent)
	 */
	public boolean affectsBehavior(PropertyChangeEvent event) {
		return fTaskTagRule.affectsBehavior(event) || fTokenStore.affectsBehavior(event);
	}

	/*
	 * @see org.eclipse.cdt.internal.ui.text.AbstractJavaScanner#adaptToPreferenceChange(org.eclipse.jface.util.PropertyChangeEvent)
	 */
	public void adaptToPreferenceChange(PropertyChangeEvent event) {
		if (fTokenStore.affectsBehavior(event)) {
			fTokenStore.adaptToPreferenceChange(event);
		}
		fTaskTagRule.adaptToPreferenceChange(event);
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools.generic;

/**
 * Record class for a generic documentation tool tag
 */
public class GenericDocTag {
	private final String name, description;
	
	/**
	 * Create a tag
	 * @param name
	 * @param description
	 */
	public GenericDocTag(String name, String description) {
		this.name= name;
		this.description= description;
	}
	
	/**
	 * @return the tag name (without any prefix i.e. no at or backslash)
	 */
	public String getTagName() {
		return name;
	}
	
	/**
	 * @return a human readable description of the tag. May be null.
	 */
	public String getTagDescription() {
		return description;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import java.util.List;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;

import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.IWorkingCopyManager;
import org.eclipse.cdt.ui.text.contentassist.ContentAssistInvocationContext;
import org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer;
import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
import org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration;


abstract class AbstractDocCommentProposalComputer implements ICompletionProposalComputer {
	
	protected abstract IDocCommentViewerConfiguration getConfiguration(IDocCommentOwner owner);
	
	protected final IDocCommentViewerConfiguration getConfiguration() {
		IResource resource= getResource();
		IDocCommentOwner owner= DocCommentOwnerManager.getInstance().getCommentOwner(resource);
		return getConfiguration(owner);
	}
	
	public List computeCompletionProposals(ContentAssistInvocationContext context, IProgressMonitor monitor) {
		return getConfiguration().createProposalComputer().computeCompletionProposals(context, monitor);
	}

	public List computeContextInformation(
			ContentAssistInvocationContext context, IProgressMonitor monitor) {
		return getConfiguration().createProposalComputer().computeContextInformation(context, monitor);
	}

	public String getErrorMessage() {
		return getConfiguration().createProposalComputer().getErrorMessage();
	}

	public void sessionEnded() {
		// XXX
	}

	public void sessionStarted() {
		// XXX
	}
	
	
	private static IResource getResource() {
		ITranslationUnit tu= getTranslationUnit();
		return tu.getResource();
	}
	
	private static ITranslationUnit getTranslationUnit() {
		IWorkbenchWindow window= PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if (window == null)
			return null;

		IWorkbenchPage page= window.getActivePage();
		if (page == null)
			return null;

		IEditorPart editor= page.getActiveEditor();
		if (editor == null)
			return null;

		IWorkingCopyManager manager= CUIPlugin.getDefault().getWorkingCopyManager();
		ITranslationUnit unit= manager.getWorkingCopy(editor.getEditorInput());
		if (unit == null)
			return null;

		return unit;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.ICDescriptor;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;

/**
 * A ProjectMap is an internal abstraction which
 * <ul>
 * <li>Maintains mappings from project relative paths to comment-owner ID's
 * <li>Manages persistence of these mappings to the .cproject file.
 * </ul>
 * for a particular {@link IProject}
 * 
 * @since 5.0
 */
class ProjectMap {
	/** .cproject xml element/attribute names **/
	private static final String ATTRVAL_STORAGEID= "org.eclipse.cdt.internal.ui.text.commentOwnerProjectMappings"; //$NON-NLS-1$
	private static final String ELEMENT_DOC_COMMENT_OWNER = "doc-comment-owner"; //$NON-NLS-1$
	private static final String ATTRKEY_DCO_ID = "id"; //$NON-NLS-1$
	private static final String ELEMENT_PATH = "path"; //$NON-NLS-1$
	private static final String ATTRKEY_PATH_VALUE = "value"; //$NON-NLS-1$
	
	private IProject fProject;
	private Map/*<IPath, String>*/ fMap;
	
	/**
	 * Loads the project map
	 * @param project
	 */
	public ProjectMap(IProject project) {
		try {
			fMap= load(project);
		} catch(CoreException ce) {
			CUIPlugin.getDefault().log(ce);
			fMap= new HashMap();
		}
		fProject= project;
	}
	
	/**
	 * Returns the id of the doc comment owner mapped to the resource specified, or null
	 * if no owner is mapped within this project. Ownership is inherited from parents and
	 *  may be overridden. 
	 * @param resource
	 * @return possibly null
	 */
	public String getOwnerID(IResource resource) {
		String id= null;
		if(resource!=null) {
			for(IPath p= resource.getProjectRelativePath(); ; p= p.removeLastSegments(1)) {
				if(fMap.containsKey(p)) {
					id= (String) fMap.get(p);
					break;
				}
				if(p.isEmpty())
					break;
			}
		}
		return id;
	}

	/**
	 * Creates a new (or updates the existing) mapping associating the specified
	 * {@link IDocCommentOwner} with the specified {@link IResource}
	 * @param resource the non-null resource to create an association for
	 * @param owner the owner to associate the resource with, or <code>null</code> to ensure there
	 * is no association.
	 */
	public void setCommentOwner(IResource resource, IDocCommentOwner owner) {
		Assert.isNotNull(resource);
		if(ResourcesPlugin.getWorkspace().getRoot().equals(resource))
			throw new IllegalStateException();
		if(owner!=null) {
			fMap.put(resource.getProjectRelativePath(), owner.getID());
		} else {
			fMap.remove(resource.getProjectRelativePath());
		}
		try {
			save();
		} catch(CoreException ce) {
			CUIPlugin.getDefault().log(ce);
		}
	}

	public boolean isEmpty() {
		return fMap.isEmpty();
	}
	
	private static Map load(IProject project) throws CoreException {
		Map result= new HashMap();
		ICDescriptor pd= CCorePlugin.getDefault().getCProjectDescription(project, true);
		Element e= pd.getProjectData(ATTRVAL_STORAGEID);
		if(e.hasChildNodes()) {
			NodeList commentOwners= e.getElementsByTagName(ELEMENT_DOC_COMMENT_OWNER);
			for(int i=0; i<commentOwners.getLength(); i++) {
				Element node= (Element) commentOwners.item(i);
				Node commentOwnerIDNode= node.getAttributes().getNamedItem(ATTRKEY_DCO_ID);

				if(commentOwnerIDNode != null) {
					String commentOwnerID= commentOwnerIDNode.getNodeValue();

					NodeList paths= node.getElementsByTagName(ELEMENT_PATH);
					for(int j=0; j<paths.getLength(); j++) {
						Node path= paths.item(i);
						Node pathValue= path.getAttributes().getNamedItem(ATTRKEY_PATH_VALUE);
						if(pathValue != null) {
							result.put(Path.fromPortableString(pathValue.getNodeValue()), commentOwnerID);
						}
					}
				}
			}
		}
		return result;
	}

	/**
	 * Write the map to the .cproject file
	 */
	public void save() throws CoreException {
		ICDescriptor pd= CCorePlugin.getDefault().getCProjectDescription(fProject, true);

		// remove current associations
		Element data= pd.getProjectData(ATTRVAL_STORAGEID);
		NodeList nl= data.getChildNodes();
		for(int i=0; i<nl.getLength(); i++) {
			Node node= nl.item(i);
			if(node.getNodeType()== Node.ELEMENT_NODE) {
				data.removeChild(node);
			}
		}

		// invert and persist associations
		for(Iterator i= fMap.values().iterator(); i.hasNext();) {
			String cid= (String) i.next();
			Element commentNode= data.getOwnerDocument().createElement(ELEMENT_DOC_COMMENT_OWNER);
			commentNode.setAttribute(ATTRKEY_DCO_ID, cid);
			for(Iterator j= fMap.keySet().iterator(); j.hasNext(); ) {
				IPath path= (IPath) j.next();
				String ccid= (String) fMap.get(path);
				if(cid.equals(ccid)) {
					Element pathNode= data.getOwnerDocument().createElement(ELEMENT_PATH);
					pathNode.setAttribute(ATTRKEY_PATH_VALUE, path.toPortableString());
					commentNode.appendChild(pathNode);
				}
			}
			data.appendChild(commentNode);
		}
		pd.saveProjectData();
	}
}




a,,
addindex,,
addtogroup,,
anchor,,
arg,,
attention,,
author,,
b,,
brief,,
bug,,
c,,
callgraph,,
callergraph,,
category,,
class,,
code,,
cond,,
copydoc,,
date,,
def,,
defgroup,,
deprecated,,
details,,
dir,,
dontinclude,,
dot,,
dotfile,,
e,,
else,,
elseif,,
em,,
endcode,,
endcond,,
enddot,,
endhtmlonly,,
endif,,
endlatexonly,,
endlink,,
endmanonly,,
endmsc,,
endverbatim,,
endxmlonly,,
enum,,
example,,
exception,,
f$,,
f[,,
f],,
file,,
fn,,
hideinitializer,,
htmlinclude,,
htmlonly,,
if,,
ifnot,,
image,,
include,,
includelineno,,
ingroup,,
internal,,
invariant,,
interface,,
latexonly,,
li,,
line,,
link,,
mainpage,,
manonly,,
msc,,
n,,
name,,
namespace,,
nosubgrouping,,
note,,
overload,,
p,,
package,,
page,,
par,,
paragraph,,
param,,
post,,
pre,,
property,,
protocol,,
ref,,
relates,,
relatesalso,,
remarks,,
return,,
retval,,
sa,,
section,,
see,,
showinitializer,,
since,,
skip,,
skipline,,
struct,,
subpage,,
subsection,,
subsubsection,,
test,,
throw,,
todo,,
typedef,,
union,,
until,,
var,,
verbatim,,
verbinclude,,
version,,
warning,,
weakgroup,,
xmlonly,,
xrefitem,,




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools.generic;

import com.ibm.icu.text.BreakIterator;
import java.text.CharacterIterator;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextDoubleClickStrategy;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.Region;

/**
 * Cloned and tweaked from JDT's javadoc double click strategy
 */
public class GenericTagDoubleClickStrategy implements ITextDoubleClickStrategy {
	protected final char[] fTagMarkers;
	
	/**
	 * A double-click strategy that additionally understands tag markers form part of a
	 * selectable word.
	 * @param tagMarkers the set of characters to additionally consider part of a word
	 */
	public GenericTagDoubleClickStrategy(char[] tagMarkers) {
		fTagMarkers= new char[tagMarkers.length];
		System.arraycopy(tagMarkers, 0, fTagMarkers, 0, tagMarkers.length);
	}
	
	/**
	 * Implements a character iterator that works directly on
	 * instances of <code>IDocument</code>. Used to collaborate with
	 * the break iterator.
	 *
	 * @see IDocument
	 * @since 2.0
	 */
	static class DocumentCharacterIterator implements CharacterIterator {

		/** Document to iterate over. */
		private IDocument fDocument;
		/** Start offset of iteration. */
		private int fOffset= -1;
		/** End offset of iteration. */
		private int fEndOffset= -1;
		/** Current offset of iteration. */
		private int fIndex= -1;

		/** Creates a new document iterator. */
		public DocumentCharacterIterator() {
		}

		/**
		 * Configures this document iterator with the document section to be visited.
		 *
		 * @param document the document to be iterated
		 * @param iteratorRange the range in the document to be iterated
		 */
		public void setDocument(IDocument document, IRegion iteratorRange) {
			fDocument= document;
			fOffset= iteratorRange.getOffset();
			fEndOffset= fOffset + iteratorRange.getLength();
		}

		/*
		 * @see CharacterIterator#first()
		 */
		public char first() {
			fIndex= fOffset;
			return current();
		}

		/*
		 * @see CharacterIterator#last()
		 */
		public char last() {
			fIndex= fOffset < fEndOffset ? fEndOffset -1 : fEndOffset;
			return current();
		}

		/*
		 * @see CharacterIterator#current()
		 */
		public char current() {
			if (fOffset <= fIndex && fIndex < fEndOffset) {
				try {
					return fDocument.getChar(fIndex);
				} catch (BadLocationException x) {
				}
			}
			return DONE;
		}

		/*
		 * @see CharacterIterator#next()
		 */
		public char next() {
			++fIndex;
			int end= getEndIndex();
			if (fIndex >= end) {
				fIndex= end;
				return DONE;
			}
			return current();
		}

		/*
		 * @see CharacterIterator#previous()
		 */
		public char previous() {
			if (fIndex == fOffset)
				return DONE;

			if (fIndex > fOffset)
				-- fIndex;

			return current();
		}

		/*
		 * @see CharacterIterator#setIndex(int)
		 */
		public char setIndex(int index) {
			fIndex= index;
			return current();
		}

		/*
		 * @see CharacterIterator#getBeginIndex()
		 */
		public int getBeginIndex() {
			return fOffset;
		}

		/*
		 * @see CharacterIterator#getEndIndex()
		 */
		public int getEndIndex() {
			return fEndOffset;
		}

		/*
		 * @see CharacterIterator#getIndex()
		 */
		public int getIndex() {
			return fIndex;
		}

		/*
		 * @see CharacterIterator#clone()
		 */
		public Object clone() {
			DocumentCharacterIterator i= new DocumentCharacterIterator();
			i.fDocument= fDocument;
			i.fIndex= fIndex;
			i.fOffset= fOffset;
			i.fEndOffset= fEndOffset;
			return i;
		}
	}


	/**
	 * The document character iterator used by this strategy.
	 * @since 2.0
	 */
	private DocumentCharacterIterator fDocIter= new DocumentCharacterIterator();

	/*
	 * @see org.eclipse.jface.text.ITextDoubleClickStrategy#doubleClicked(org.eclipse.jface.text.ITextViewer)
	 */
	public void doubleClicked(ITextViewer text) {

		int position= text.getSelectedRange().x;

		if (position < 0)
			return;

		IRegion word= getWordRegion(text.getDocument(), position);

		if (word != null)
			text.setSelectedRange(word.getOffset(), word.getLength());
	}

	/**
	 * Returns a region describing the word around <code>position</code>.
	 *
	 * @param document the document
	 * @param position the offset around which to return the word
	 * @return the word's region, or <code>null</code> for no selection
	 */
	private IRegion getWordRegion(IDocument document, int position) {
		try {

			IRegion line= document.getLineInformationOfOffset(position);
			if (position == line.getOffset() + line.getLength())
				return null;

			fDocIter.setDocument(document, line);

			BreakIterator breakIter= BreakIterator.getWordInstance();
			breakIter.setText(fDocIter);

			int start= breakIter.preceding(position);
			if (start == BreakIterator.DONE)
				start= line.getOffset();

			int end= breakIter.following(position);
			if (end == BreakIterator.DONE)
				end= line.getOffset() + line.getLength();

			if (breakIter.isBoundary(position)) {
				if (end - position > position- start)
					start= position;
				else
					end= position;
			}

			if (start > 0 && isTagMarker(document.getChar(start - 1)) && Character.isJavaIdentifierPart(document.getChar(start))
					&& (start == 1 || Character.isWhitespace(document.getChar(start - 2)) || document.getChar(start - 2) == '{')) {
				// double click after @ident
				start--;
			} else if (end == position && end == start + 1 && end < line.getOffset() + line.getLength() && document.getChar(end) == '@') {
				// double click before " @ident"
				return getWordRegion(document, position + 1);
			}

			if (start == end)
				return null;
			return new Region(start, end - start);

		} catch (BadLocationException x) {
			return null;
		}
	}


	protected boolean isTagMarker(char c) {
		for(int i=0; i<fTagMarkers.length; i++) {
			if(c == fTagMarkers[i])
				return true;
		}
		return false;
	}
}




package org.eclipse.cdt.internal.ui.text.doctools.docpp;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.generic.AbstractGenericTagDocCommentViewerConfiguration;

public class DocppMultilineConfiguration extends AbstractGenericTagDocCommentViewerConfiguration {
	
	public DocppMultilineConfiguration() {
		super(DocppHelper.getDocPPTags(), new char[] {'@','\\'}, DocppHelper.DOCPP_MULTI_TOKEN, DocppHelper.DOCPP_TAG_RECOGNIZED);
	}
	
	public IAutoEditStrategy createAutoEditStrategy() {
		return new DocppMultilineAutoEditStrategy();
	}
	
	public boolean isDocumentationComment(IDocument doc, int offset, int length) {
		try {
			if(offset+2 < doc.getLength()) {
				char c= doc.getChar(offset+2);
				if(c == '@') {
					if(offset + 3 < doc.getLength()) {
						char d= doc.getChar(offset+3); 
						return d == '{' || d == '}';
					}
				}
				return c == '*';
			}
		} catch(BadLocationException ble) {
			CUIPlugin.getDefault().log(ble);
		}
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools;

import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextDoubleClickStrategy;

import org.eclipse.cdt.ui.text.ICPartitions;
import org.eclipse.cdt.ui.text.ICTokenScanner;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;
import org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer;

/**
 * An IDocCommentViewerConfiguration aggregates a collection of editor tools that can be contributed to
 * the CDT editor. The tools will be active for CEditor partitions of type {@link ICPartitions#C_MULTI_LINE_DOC_COMMENT} or 
 * {@link ICPartitions#C_SINGLE_LINE_DOC_COMMENT} when the {@link IDocCommentOwner} this instance originated from is active.
 * 
 * @see org.eclipse.jface.text.source.SourceViewerConfiguration (in analogy to)
 * @since 5.0
 */
public interface IDocCommentViewerConfiguration {
	/**
	 * @param doc the document to examine
	 * @param offset the offset of the start of the region (inclusive)
	 * @param length the length of the region to examine
	 * @return whether the region specified is a documentation comment handled by this viewer configuration
	 */
	boolean isDocumentationComment(IDocument doc, int offset, int length);
	
	/**
	 * @return a ICTokenScanner for tokenising/coloring the appropriate comment region. May return null.
	 */
	ICTokenScanner createCommentScanner(ITokenStoreFactory tokenStoreFactory);
	
	/**
	 * @return an auto edit strategy suitable for the appropriate comment region. May return null
	 * in the case where no auto-edit-strategy is required.
	 */
	IAutoEditStrategy createAutoEditStrategy();
	
	/**
	 * @return a double click strategy suitable for the associated comment-region. May return null in
	 * the case where no double-click-strategy is required.
	 */
	ITextDoubleClickStrategy createDoubleClickStrategy();
	
	/**
	 * @return a completion proposal computer suitable for the associated comment-region. May return null in
	 * the case where no proposal-computer is required.
	 */
	ICompletionProposalComputer createProposalComputer();
	
	/**
	 * @return a {@link IDocCommentDictionary} suitable for spell-checking. May return null
	 * in the case where no additional dictionary is required.
	 */
	IDocCommentDictionary getSpellingDictionary();
}




package org.eclipse.cdt.internal.ui.text.doctools.doxygen;

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

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITypedRegion;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.ast.IASTCompositeTypeSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTFunctionDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition;
import org.eclipse.cdt.core.dom.ast.IASTNodeLocation;
import org.eclipse.cdt.core.dom.ast.IASTParameterDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTStandardFunctionDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier.IASTEnumerator;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateDeclaration;
import org.eclipse.cdt.ui.text.doctools.DefaultMultilineCommentAutoEditStrategy;

/**
 * {@link IAutoEditStrategy} for adding Doxygen tags for comments.
 */
public class DoxygenMultilineAutoEditStrategy extends DefaultMultilineCommentAutoEditStrategy {
	private static final String SINGLELINE_COMMENT_PRECEDING = "//!< "; //$NON-NLS-1$
	private static final String PARAM = "@param "; //$NON-NLS-1$
	private static final String RETURN = "@return\n"; //$NON-NLS-1$

	protected StringBuffer paramTags(IASTParameterDeclaration[] decls) {
		StringBuffer result= new StringBuffer();
		for(int i=0; i<decls.length; i++) {
			IASTDeclarator dtor= decls[i].getDeclarator();
			result.append(PARAM+dtor.getName()+"\n"); //$NON-NLS-1$
		}
		return result;
	}

	protected StringBuffer returnTag() {
		return new StringBuffer(RETURN);
	}

	protected IASTParameterDeclaration[] getParameterDecls(IASTFunctionDefinition def) {
		IASTParameterDeclaration[] result;
		IASTFunctionDeclarator decl= def.getDeclarator();
		if (decl instanceof IASTStandardFunctionDeclarator) {
			IASTStandardFunctionDeclarator standardFunctionDecl= (IASTStandardFunctionDeclarator)decl;
			result= standardFunctionDecl.getParameters();
		} else /*if (def instanceof ICASTKnRFunctionDeclarator) {
			ICASTKnRFunctionDeclarator knrDeclarator= (ICASTKnRFunctionDeclarator)decl;
			result= knrDeclarator.getParameterDeclarations();
		} else */{
			result= new IASTParameterDeclaration[0];
		}
		return result;
	}

	public StringBuffer customizeAfterNewLineForDeclaration(IDocument doc, IASTDeclaration dec, ITypedRegion partition) {
		StringBuffer result= new StringBuffer();

		while(dec instanceof ICPPASTTemplateDeclaration) /* if? */
			dec= ((ICPPASTTemplateDeclaration)dec).getDeclaration(); 

		if(dec instanceof IASTFunctionDefinition) {
			IASTFunctionDefinition fd= (IASTFunctionDefinition) dec;
			result.append(paramTags(getParameterDecls(fd)));

			IASTDeclSpecifier ds= fd.getDeclSpecifier();
			boolean hasReturn= true;
			if(ds instanceof IASTSimpleDeclSpecifier) {
				IASTSimpleDeclSpecifier sds= (IASTSimpleDeclSpecifier) ds;
				if(sds.getType()==IASTSimpleDeclSpecifier.t_void) {
					hasReturn= false;
				}
			}
			if(hasReturn) {
				result.append(returnTag());
			}

			return result;
		}

		if(dec instanceof IASTSimpleDeclaration && ((IASTSimpleDeclaration)dec).getDeclSpecifier() instanceof IASTCompositeTypeSpecifier) {
			// result.append("@publishedAll");
			return result;
		}


		try {
			alterDoc(doc, dec);
		} catch(BadLocationException ble) {}

		return new StringBuffer();
	}

	/*
	 * Prototype code for adding post-declaration comments to enumerators, after initialiting a doc-comment
	 * on an enumeration
	 */
	private void alterDoc(IDocument doc, IASTDeclaration dec) throws BadLocationException {
		if(dec instanceof IASTSimpleDeclaration && ((IASTSimpleDeclaration)dec).getDeclSpecifier() instanceof IASTEnumerationSpecifier) {
			IASTEnumerationSpecifier spc= (IASTEnumerationSpecifier)  ((IASTSimpleDeclaration)dec).getDeclSpecifier();
			IASTEnumerator[] enms= spc.getEnumerators();

			class Entry {
				final int offset, length;
				String comment;
				Entry(int offset, int length, String comment) {
					this.offset= offset;
					this.length= length;
					this.comment= comment;
				}
			}

			List entries= new ArrayList();
			for(int i=0; i<enms.length; i++) {
				IASTNodeLocation[] locs= (enms[i].getName().getNodeLocations());
				if(locs.length==1) {
					int offset2= locs[0].getNodeOffset()+locs[0].getNodeLength();
					System.out.println(offset2);
					String cmt= SINGLELINE_COMMENT_PRECEDING+enms[i].getName();
					IRegion region= doc.getLineInformationOfOffset(offset2);
					entries.add(new Entry(region.getOffset(),region.getLength(), cmt));
				} else {
					// TODO
					CCorePlugin.log("TODO"); //$NON-NLS-1$
				}
			}

			int max= Integer.MIN_VALUE;
			for(int i=0; i<entries.size(); i++) {
				Entry e= (Entry) entries.get(i);
				if(e.length > max)
					max= e.length;
			}


			int addedLength2=0;
			for(int i=0; i<entries.size(); i++) {
				Entry e= (Entry) entries.get(i);
				// pad with whitespace
				int toAdd= max-e.length;
				for(int j=0; j<toAdd; j++) {
					e.comment= " "+e.comment; //$NON-NLS-1$
				}
				doc.replace(e.offset+e.length+addedLength2, 0, e.comment);
				addedLength2+= e.comment.length();
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006, 2007 IBM Corporation and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     QNX Software System
 *     Andrew Ferguson (Symbian) - refactored to TokenStore (previously part of AbstractCScanner)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text;


import java.util.HashMap;
import java.util.Map;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.resource.StringConverter;
import org.eclipse.jface.text.TextAttribute;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Display;

import org.eclipse.cdt.ui.PreferenceConstants;
import org.eclipse.cdt.ui.text.ITokenStore;


/**
 * Maintains a pool of tokens identified by a String ID.
 * Supports styles per token.
 * Updates token instances on property changes.
 */

public class TokenStore implements ITokenStore {
	private IColorManager fColorManager;
	private IPreferenceStore fPreferenceStore;

	private Map fTokenMap= new HashMap();
	private String[] fPropertyNamesColor;

	private boolean fNeedsLazyColorLoading;
	
	/**
	 * Maintains tokens for a specified set of property keys. Automatically also
	 * copes with bold, italic, strikethrough and underlined versions of the key.
	 * @param manager the IColorManager to retrieve token colors from
	 * @param store the {@link IPreferenceStore} to fetch property preferences from
	 */
	public TokenStore(IColorManager manager, IPreferenceStore store, String[] propertyNamesColor) {
		fColorManager= manager;
		fPreferenceStore= store;
	
		fPropertyNamesColor= propertyNamesColor;

		fNeedsLazyColorLoading= Display.getCurrent() == null;
		for (int i= 0; i < fPropertyNamesColor.length; i++) {			
			if(fPropertyNamesColor[i].endsWith(PreferenceConstants.EDITOR_BOLD_SUFFIX)
					|| fPropertyNamesColor[i].endsWith(PreferenceConstants.EDITOR_ITALIC_SUFFIX)
					|| fPropertyNamesColor[i].endsWith(PreferenceConstants.EDITOR_STRIKETHROUGH_SUFFIX)
					|| fPropertyNamesColor[i].endsWith(PreferenceConstants.EDITOR_UNDERLINE_SUFFIX)) {
				throw new IllegalArgumentException(); // XXX
			}
			if (fNeedsLazyColorLoading)
				addTokenWithProxyAttribute(fPropertyNamesColor[i]);
			else
				addToken(fPropertyNamesColor[i]);
		}
	}
	
	/**
	 * In the case where at the time of IToken construction, the Display was not
	 * ready to construct colors. 
	 */
	public void ensureTokensInitialised() {
		if (fNeedsLazyColorLoading && Display.getCurrent() != null) {
			for (int i= 0; i < fPropertyNamesColor.length; i++) {
				addToken(fPropertyNamesColor[i]);
			}
			fNeedsLazyColorLoading= false;
		}
	}

	private void addTokenWithProxyAttribute(String colorKey) {
		fTokenMap.put(colorKey, new Token(createTextAttribute(colorKey, true)));
	}

	private void addToken(String colorKey) {
		if (fColorManager != null && colorKey != null && fColorManager.getColor(colorKey) == null) {
			RGB rgb= PreferenceConverter.getColor(fPreferenceStore, colorKey);
			if (fColorManager instanceof IColorManagerExtension) {
				IColorManagerExtension ext= (IColorManagerExtension) fColorManager;
				ext.unbindColor(colorKey);
				ext.bindColor(colorKey, rgb);
			}
		}

		if (!fNeedsLazyColorLoading)
			fTokenMap.put(colorKey, new Token(createTextAttribute(colorKey, false)));
		else {
			Token token= ((Token)fTokenMap.get(colorKey));
			if (token != null)
				token.setData(createTextAttribute(colorKey, false));
		}
	}

	/**
	 * Create a text attribute based on the given color, bold, italic, strikethrough and underline preference keys.
	 *
	 * @param colorKey the color preference key
	 * @param boldKey the bold preference key
	 * @param italicKey the italic preference key
	 * @param strikethroughKey the strikethrough preference key
	 * @param underlineKey the italic preference key
	 * @return the created text attribute
	 * @since 3.0
	 */
	private TextAttribute createTextAttribute(String colorKey, boolean isNull) {
		Color color= null;
		if (!isNull)
			color= fColorManager.getColor(colorKey);

		String boldKey= colorKey + PreferenceConstants.EDITOR_BOLD_SUFFIX;
		String italicKey= colorKey + PreferenceConstants.EDITOR_ITALIC_SUFFIX;
		String strikethroughKey= colorKey + PreferenceConstants.EDITOR_STRIKETHROUGH_SUFFIX;
		String underlineKey= colorKey + PreferenceConstants.EDITOR_UNDERLINE_SUFFIX;
		
		int style= fPreferenceStore.getBoolean(boldKey) ? SWT.BOLD : SWT.NORMAL;
		if (fPreferenceStore.getBoolean(italicKey))
			style |= SWT.ITALIC;

		if (fPreferenceStore.getBoolean(strikethroughKey))
			style |= TextAttribute.STRIKETHROUGH;

		if (fPreferenceStore.getBoolean(underlineKey))
			style |= TextAttribute.UNDERLINE;

		return new TextAttribute(color, null, style);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.cdt.ui.text.ITokenStore#getToken(java.lang.String)
	 */
	public IToken getToken(String key) {
		return getTokenInner(key);
	}
	
	private Token getTokenInner(String key) {
		ensureTokensInitialised();
		return (Token) fTokenMap.get(key);
	}

	private int indexOf(String property) {
		if (property != null) {
			int length= fPropertyNamesColor.length;
			for (int i= 0; i < length; i++) {
				if (property.startsWith(fPropertyNamesColor[i])) {
					int pLength= property.length();
					if(fPropertyNamesColor[i].length() < pLength) {
						String end= property.substring(fPropertyNamesColor[i].length());
						if (end.equals(PreferenceConstants.EDITOR_BOLD_SUFFIX)
							|| end.equals(PreferenceConstants.EDITOR_ITALIC_SUFFIX)
							|| end.equals(PreferenceConstants.EDITOR_STRIKETHROUGH_SUFFIX)
							|| end.equals(PreferenceConstants.EDITOR_UNDERLINE_SUFFIX)) {
							return i;						
						}
					} else if (fPropertyNamesColor[i].equals(property)) {
						return i;
					}
				}
			}
		}
		return -1;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.cdt.ui.IPropertyChangeParticipant#affectsBehavior(org.eclipse.jface.util.PropertyChangeEvent)
	 */
	public boolean affectsBehavior(PropertyChangeEvent event) {
		return indexOf(event.getProperty()) >= 0;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.cdt.ui.IPropertyChangeParticipant#adaptToPreferenceChange(org.eclipse.jface.util.PropertyChangeEvent)
	 */
	public void adaptToPreferenceChange(PropertyChangeEvent event) {
		String property= event.getProperty();
		int i= indexOf(property);
		if (property.startsWith(fPropertyNamesColor[i])) {
			Token token= getTokenInner(fPropertyNamesColor[i]);
			if(property.length() == fPropertyNamesColor[i].length()) {
				adaptToColorChange(token, event);
			} else {
				String end= property.substring(fPropertyNamesColor[i].length());				
				if (end.equals(PreferenceConstants.EDITOR_BOLD_SUFFIX)) {
					adaptToStyleChange(token, event, SWT.BOLD);
				} else if (end.equals(PreferenceConstants.EDITOR_ITALIC_SUFFIX)) {
					adaptToStyleChange(token, event, SWT.ITALIC);
				} else if (end.equals(PreferenceConstants.EDITOR_STRIKETHROUGH_SUFFIX)) {
					adaptToStyleChange(token, event, TextAttribute.STRIKETHROUGH);
				} else if (end.equals(PreferenceConstants.EDITOR_UNDERLINE_SUFFIX)) {
					adaptToStyleChange(token, event, TextAttribute.UNDERLINE);
				}
			}
		}
	}

	private void adaptToColorChange(Token token, PropertyChangeEvent event) {
		RGB rgb= null;

		Object value= event.getNewValue();
		if (value instanceof RGB)
			rgb= (RGB) value;
		else if (value instanceof String)
			rgb= StringConverter.asRGB((String) value);

		if (rgb != null) {

			String property= event.getProperty();
			Color color= fColorManager.getColor(property);

			if ((color == null || !rgb.equals(color.getRGB())) && fColorManager instanceof IColorManagerExtension) {
				IColorManagerExtension ext= (IColorManagerExtension) fColorManager;

			 	ext.unbindColor(property);
			 	ext.bindColor(property, rgb);

				color= fColorManager.getColor(property);
			}

			Object data= token.getData();
			if (data instanceof TextAttribute) {
				TextAttribute oldAttr= (TextAttribute) data;
				token.setData(new TextAttribute(color, oldAttr.getBackground(), oldAttr.getStyle()));
			}
		}
	}

	private void adaptToStyleChange(Token token, PropertyChangeEvent event, int styleAttribute) {
		boolean eventValue= false;
		Object value= event.getNewValue();
		if (value instanceof Boolean)
			eventValue= ((Boolean) value).booleanValue();
		else if (IPreferenceStore.TRUE.equals(value))
			eventValue= true;

		Object data= token.getData();
		if (data instanceof TextAttribute) {
			TextAttribute oldAttr= (TextAttribute) data;
			boolean activeValue= (oldAttr.getStyle() & styleAttribute) == styleAttribute;
			if (activeValue != eventValue)
				token.setData(new TextAttribute(oldAttr.getForeground(), oldAttr.getBackground(), eventValue ? oldAttr.getStyle() | styleAttribute : oldAttr.getStyle() & ~styleAttribute));
		}
	}
	
	/**
	 * Returns the preference store.
	 *
	 * @return the preference store.
	 *
	 * @since 3.0
	 */
	public IPreferenceStore getPreferenceStore() {
		return fPreferenceStore;
	}
}




package org.eclipse.cdt.internal.ui.text.doctools.doxygen;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.swt.graphics.RGB;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.generic.GenericDocTag;

/**
 * Controls the life-cycle of the Doxygen comment editor support
 */
public class DoxygenHelper {
	/*
	 * TODO - This is a temporary location
	 */
	private static final IPath TAGS_CSV= new Path("src/org/eclipse/cdt/internal/ui/text/doctools/doxygen/tags.csv"); //$NON-NLS-1$
	
	static {
		// TODO - I'll find a legitimate place to do this
		IPreferenceStore cuis= CUIPlugin.getDefault().getPreferenceStore();
		PreferenceConverter.setDefault(cuis, DoxygenHelper.DOXYGEN_MULTI_TOKEN, new RGB(63, 95, 191));
		PreferenceConverter.setDefault(cuis, DoxygenHelper.DOXYGEN_SINGLE_TOKEN, new RGB(63, 95, 191));
		PreferenceConverter.setDefault(cuis, DoxygenHelper.DOXYGEN_TAG_RECOGNIZED, new RGB(127, 159, 191));
	}
	
	
	private static GenericDocTag[] tags;
	public static final String DOXYGEN_TAG_RECOGNIZED= "org.eclipse.cdt.internal.ui.text.doctools.doxygen.recognizedTag"; //$NON-NLS-1$
	public static final String DOXYGEN_SINGLE_TOKEN= "org.eclipse.cdt.internal.ui.text.doctools.doxygen.single"; //$NON-NLS-1$
	public static final String DOXYGEN_MULTI_TOKEN= "org.eclipse.cdt.internal.ui.text.doctools.doxygen.multi"; //$NON-NLS-1$
	
	public static GenericDocTag[] getDoxygenTags() {
		if(tags==null) {
			try {
				List temp= new ArrayList();
				InputStream is= FileLocator.openStream(CUIPlugin.getDefault().getBundle(), TAGS_CSV, false);
				BufferedReader br= new BufferedReader(new InputStreamReader(is));
				StringBuffer content= new StringBuffer();
				for(String line= br.readLine(); line!=null; line= br.readLine()) {
					content.append(line+"\n"); //$NON-NLS-1$
				}
				String[] values= content.toString().split("(\\s)*,(\\s)*"); //$NON-NLS-1$
				
				for(int i=0; i+1<values.length; i+=2) {
					temp.add(new GenericDocTag(values[i], values[i+1]));
				}
				tags= (GenericDocTag[]) temp.toArray(new GenericDocTag[temp.size()]);
			} catch(IOException ioe) {
				
			}
				
		}
		return tags;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.progress.WorkbenchJob;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.model.CModelException;
import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
import org.eclipse.cdt.ui.text.doctools.IDocCommentOwnershipListener;

import org.eclipse.cdt.internal.ui.editor.ITranslationUnitEditorInput;
import org.eclipse.cdt.internal.ui.util.EditorUtility;
import org.eclipse.cdt.internal.ui.util.ExternalEditorInput;

/**
 * Listens to change in doc-comment ownership and reinitializes
 * the editors (or a safe superset of) that need reopening.
 */
public class EditorReopener implements IDocCommentOwnershipListener {

	/*
	 * @see org.eclipse.cdt.ui.text.doctools.IDocCommentOwnershipListener#ownershipChanged(org.eclipse.core.resources.IResource, boolean, org.eclipse.cdt.ui.text.doctools.IDocCommentOwner, org.eclipse.cdt.ui.text.doctools.IDocCommentOwner)
	 */
	public void ownershipChanged(IResource resource, boolean recursive,
			IDocCommentOwner old, IDocCommentOwner newOwner) {
		IWorkbenchWindow window= PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if(window!=null) {
			try {
				IEditorPart[] parts= getEditorsToRepon(window, resource);
				if(queryIfNeeded(window.getShell(), parts)) {
					reopenEditors(window, parts);
				}
			} catch(CoreException ce) {
				CCorePlugin.log(ce);
			}
		}
	}

	/*
	 * @see org.eclipse.cdt.ui.text.doctools.IDocCommentOwnershipListener#workspaceOwnershipChanged(org.eclipse.cdt.ui.text.doctools.IDocCommentOwner, org.eclipse.cdt.ui.text.doctools.IDocCommentOwner)
	 */
	public void workspaceOwnershipChanged(IDocCommentOwner old, IDocCommentOwner newOwner) {
		IWorkbenchWindow window= PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if(window!=null) {
			try {
				IEditorPart[] parts= getEditorsToRepon(window, null);
				if(queryIfNeeded(window.getShell(), parts)) {
					reopenEditors(window, parts);
				}
			} catch(CoreException ce) {
				CCorePlugin.log(ce);
			}
		}
	}

	/**
	 * @param window
	 * @param resource may be null to indicate all CDT editors should be reopened
	 * @return an array of {@link IEditorPart} objects that might need to be reinitialized
	 * based on doc-comment ownership of the specified resource changing
	 */
	/*
	 * This could be smarter in determining smaller sets of editors to re-open
	 */
	private IEditorPart[] getEditorsToRepon(IWorkbenchWindow window, IResource resource) {
		List needReopening= new ArrayList();
		if(window.getActivePage()!=null) {
			IEditorReference[] es= window.getActivePage().getEditorReferences();
			for(int i=0; i<es.length; i++) {
				IEditorPart part= es[i].getEditor(false);
				if(part!=null) {
					IEditorInput iei= part.getEditorInput();
					if(resource!=null) {
						if(iei instanceof IFileEditorInput) {
							IFile file= ((IFileEditorInput) iei).getFile();
							IProject project= resource.getProject();
							if(file.getProject().equals(project) && CoreModel.hasCNature(project)) {
								needReopening.add(part);
							}
						}
					} else {
						if(iei instanceof ITranslationUnitEditorInput) {
							needReopening.add(part);
						}
					}
				}
			}
		}
		return (IEditorPart[]) needReopening.toArray(new IEditorPart[needReopening.size()]);
	}

	private boolean queryIfNeeded(Shell shell, IEditorPart[] editorParts) throws CoreException {
		boolean anyUnsaved= false;
		for(int j=0; j<editorParts.length; j++)
			if(editorParts[j].isSaveOnCloseNeeded())
				anyUnsaved= true;

		boolean saveAndReopen= !anyUnsaved;
		if(anyUnsaved) {
			String title= Messages.EditorReopener_ShouldSave_Title;
			String msg= Messages.EditorReopener_ShouldSave_Message; 

			if (MessageDialog.openQuestion(shell, title, msg))
				saveAndReopen= true;
		}
		return saveAndReopen;
	}

	private void reopenEditors(final IWorkbenchWindow window, final IEditorPart[] editorParts) throws CoreException {
		WorkbenchJob job= new WorkbenchJob(Messages.EditorReopener_ReopenJobStart) {
			public IStatus runInUIThread(IProgressMonitor monitor) {
				IEditorPart oldActive= window.getActivePage().getActiveEditor();
				IEditorPart newActive= null;

				for(int j=0; j<editorParts.length; j++) {
					IEditorPart oldPart= editorParts[j];
					oldPart.doSave(new NullProgressMonitor());
					window.getActivePage().closeEditor(oldPart, false);
					IEditorInput oldInput= oldPart.getEditorInput();

					try {
						IEditorPart newPart= null;
						if(oldInput instanceof IFileEditorInput) {
							newPart= EditorUtility.openInEditor(((IFileEditorInput)oldInput).getFile());
						} else if(oldInput instanceof ExternalEditorInput) {
							ExternalEditorInput eei= (ExternalEditorInput) oldInput;
							ICElement element= CoreModel.getDefault().create(eei.getMarkerResource());
							newPart= EditorUtility.openInEditor(eei.getPath(null), element);
						}
						if(oldPart == oldActive)
							newActive= newPart;
					} catch(PartInitException pie) {
						CCorePlugin.log(pie);
					} catch(CModelException cme) {
						CCorePlugin.log(cme);
					}
				}

				if(newActive != null) {
					window.getActivePage().activate(newActive);
				}
				return new Status(IStatus.OK, CUIPlugin.PLUGIN_ID, Messages.EditorReopener_ReopenJobComplete);
			}
		};
		job.schedule();
	}
}




args,,
author,,
deprecated,,
doc,,
exception,,
field,,
friends,,
invariant,,
memo,,
name,,
param,,
postcondition,,
precondition,,
return,,
see,,
since,,
type,,
version,,





package org.eclipse.cdt.internal.ui.text.doctools.docpp;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.swt.graphics.RGB;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.generic.GenericDocTag;

/**
 * Controls the life-cycle of the Doxygen comment editor support
 */
public class DocppHelper {
	/*
	 * TODO - This is a temporary location
	 */
	private static final IPath TAGS_CSV= new Path("src/org/eclipse/cdt/internal/ui/text/doctools/docpp/tags.csv"); //$NON-NLS-1$
	
	static {
		// TODO - I'll find a legitimate place to do this
		IPreferenceStore cuis= CUIPlugin.getDefault().getPreferenceStore();
		PreferenceConverter.setDefault(cuis, DocppHelper.DOCPP_MULTI_TOKEN, new RGB(63, 95, 191));
		PreferenceConverter.setDefault(cuis, DocppHelper.DOCPP_SINGLE_TOKEN, new RGB(63, 95, 191));
		PreferenceConverter.setDefault(cuis, DocppHelper.DOCPP_TAG_RECOGNIZED, new RGB(127, 159, 191));
	}
	
	
	private static GenericDocTag[] tags;
	public static final String DOCPP_TAG_RECOGNIZED= "org.eclipse.cdt.internal.ui.text.doctools.doxygen.recognizedTag"; //$NON-NLS-1$
	public static final String DOCPP_SINGLE_TOKEN= "org.eclipse.cdt.internal.ui.text.doctools.doxygen.single"; //$NON-NLS-1$
	public static final String DOCPP_MULTI_TOKEN= "org.eclipse.cdt.internal.ui.text.doctools.doxygen.multi"; //$NON-NLS-1$
	
	public static GenericDocTag[] getDocPPTags() {
		if(tags==null) {
			try {
				List temp= new ArrayList();
				InputStream is= FileLocator.openStream(CUIPlugin.getDefault().getBundle(), TAGS_CSV, false);
				BufferedReader br= new BufferedReader(new InputStreamReader(is));
				StringBuffer content= new StringBuffer();
				for(String line= br.readLine(); line!=null; line= br.readLine()) {
					content.append(line+"\n"); //$NON-NLS-1$
				}
				String[] values= content.toString().split("(\\s)*,(\\s)*"); //$NON-NLS-1$
				
				for(int i=0; i+1<values.length; i+=2) {
					temp.add(new GenericDocTag(values[i], values[i+1]));
				}
				tags= (GenericDocTag[]) temp.toArray(new GenericDocTag[temp.size()]);
			} catch(IOException ioe) {
				
			}
				
		}
		return tags;
	}
}




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.cdt.ui">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.cdt.ui" id="DocCommentOwner" name="DocCommentOwner"/>
      </appInfo>
      <documentation>
         [Enter description of this extension point.]
      </documentation>
   </annotation>

   <element name="extension">
      <complexType>
         <choice>
            <element ref="owner"/>
         </choice>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="owner">
      <complexType>
         <attribute name="id" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="multiline" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn=":org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="singleline" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn=":org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         5.0
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         [Enter extension point usage example here.]
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiInfo"/>
      </appInfo>
      <documentation>
         [Enter API information here.]
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         [Enter information about supplied implementation of this extension point.]
      </documentation>
   </annotation>


</schema>




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools;

/**
 * This interface is a place-holder for the future. Clients should implement the most
 * appropriate sub-interface (provided by CDT). Currently {@link IDocCommentSimpleDictionary} is
 * the only provided sub-interface, but it is expected a more subtle way of integrating spell-checking
 * will be available in the future.
 * @since 5.0
 */
public interface IDocCommentDictionary {}




/*******************************************************************************
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Anton Leherbauer (Wind River Systems)
 *     Sergey Prigogin  (Google)
 *     Andrew Ferguson  (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.ui.text;

import org.eclipse.core.runtime.Preferences;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.IWordDetector;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.jface.text.rules.WordRule;
import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.cdt.core.CCorePreferenceConstants;
import org.eclipse.cdt.ui.IPropertyChangeParticipant;

/**
 * 
 * Which words should be recognized as task tags is specified under {@link CCorePreferenceConstants#TODO_TASK_TAGS} as a
 * comma delimited list.
 * 
 * @see CCorePreferenceConstants#TODO_TASK_TAGS
 * @since 5.0
 */
public final class TaskTagRule extends WordRule implements IPropertyChangeParticipant {	
	private static class TaskTagDetector implements IWordDetector {
		public boolean isWordStart(char c) {
			return Character.isLetter(c);
		}
		public boolean isWordPart(char c) {
			return Character.isLetter(c);
		}
	}

	/**
	 * Convenience method for extracting a list of words that should be recognized as 
	 * task labels from an {@link IPreferenceStore} and a backup {@link Preferences}
	 * @param preferenceStore
	 * @param corePreferences
	 * @return a list of words that should be recognized as task labels in the format
	 * expected by TaskTagRule
	 */
	public static String getTaskWords(IPreferenceStore preferenceStore, Preferences corePreferences) {
		String result= null;
		if (preferenceStore.contains(CCorePreferenceConstants.TODO_TASK_TAGS)) {
			result= preferenceStore.getString(CCorePreferenceConstants.TODO_TASK_TAGS);
		} else if (corePreferences != null) {
			result= corePreferences.getString(CCorePreferenceConstants.TODO_TASK_TAGS);
		}
		return result;
	}

	private IToken fToken;

	/**
	 * Creates a new task tag rule
	 * @param token the token to return for words recognized as task tags
	 * @param taskWords a comma delimited list of words to recognize as task tags
	 */
	public TaskTagRule(IToken token, String taskWords) {
		super(new TaskTagDetector(), Token.UNDEFINED);
		fToken= token;
		if( taskWords!= null) {
			addTaskTags(taskWords);
		}
	}

	/**
	 * Removes the current list of words that should be
	 * recognized as task tags.
	 */
	public void clearTaskTags() {
		fWords.clear();
	}

	/**
	 * Adds tags from the specified string as task tags.
	 * @param value a comma delimited list of words to recognize as task tags
	 */
	public void addTaskTags(String value) {
		String[] tasks= value.split(","); //$NON-NLS-1$
		for (int i= 0; i < tasks.length; i++) {
			if (tasks[i].length() > 0) {
				addWord(tasks[i], fToken);
			}
		}
	}

	/*
	 * @see org.eclipse.cdt.ui.IPropertyChangeParticipant#affectsBehavior(org.eclipse.jface.util.PropertyChangeEvent)
	 */
	public boolean affectsBehavior(PropertyChangeEvent event) {
		return event.getProperty().equals(CCorePreferenceConstants.TODO_TASK_TAGS);
	}

	/*
	 * @see org.eclipse.cdt.ui.IPropertyChangeParticipant#adaptToPreferenceChange(org.eclipse.jface.util.PropertyChangeEvent)
	 */
	public void adaptToPreferenceChange(PropertyChangeEvent event) {
		if (event.getProperty().equals(CCorePreferenceConstants.TODO_TASK_TAGS)) {
			Object value= event.getNewValue();

			if (value instanceof String) {
				clearTaskTags();
				addTaskTags((String) value);
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.dialogs;

import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;

import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
import org.eclipse.cdt.utils.ui.controls.ControlFactory;

public class DocCommentOwnerComposite extends Composite {
	protected DocCommentOwnerCombo fDocCombo;
	protected Label desc, comboLabel;
	protected Group group;
	
	public DocCommentOwnerComposite(Composite parent, IDocCommentOwner initialOwner, String description, String label) {
		super(parent, SWT.NONE);
		GridLayout gl= new GridLayout();
		gl.marginHeight= gl.marginWidth= 0;
		setLayout(gl);
		
		group = ControlFactory.createGroup(this, DialogsMessages.DocCommentOwnerComposite_DocumentationToolGroupTitle, 2);
		group.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());
		
		desc= new Label(group, SWT.WRAP);
		GridData gd = GridDataFactory.fillDefaults().grab(false, false).span(2, 1).create();
		gd.widthHint= 150;
		desc.setText(description);
		desc.setLayoutData(gd);
		
		comboLabel= new Label(group, SWT.NONE);
		comboLabel.setText(label);
		
		fDocCombo= new DocCommentOwnerCombo(group, SWT.NONE, initialOwner) {};
		gd = GridDataFactory.fillDefaults().grab(true, false).create();
		fDocCombo.setLayoutData(gd);
	}
	
	public IDocCommentOwner getSelectedDocCommentOwner() {
		return fDocCombo.getSelectedDocCommentOwner();
	}
	
	public void setEnabled(boolean enabled) {
		desc.setEnabled(enabled);
		comboLabel.setEnabled(enabled);
		fDocCombo.setEnabled(enabled);
		group.setEnabled(enabled);
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools.generic;

import org.eclipse.cdt.ui.text.doctools.IDocCommentSimpleDictionary;

/**
 * An implementation of a trivial dictionary
 */
public class GenericTagSimpleDictionary implements IDocCommentSimpleDictionary {
	protected String[] fTags;

	/**
	 * @param tagMarkers the characters that may delimit the start of a tag
	 * @param tags the tags that should be recognised as correct
	 */
	public GenericTagSimpleDictionary(char[] tagMarkers, GenericDocTag[] tags) {
		fTags= new String[tags.length];

		for(int j=0; j<tags.length; j++) {
			fTags[j]= tags[j].getTagName();
		}
	}

	/**
	 * 
	 */
	public String[] getAdditionalWords() {
		return fTags;
	}
}

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/text/doctools/messages.properties (+5 lines)
1	EditorReopener_ReopenJobComplete=Re-initializing editors complete
2	EditorReopener_ReopenJobStart=Re-initializing editors
3	EditorReopener_ShouldSave_Message=To react to this change, its necessary to reinitialize some unsaved editors. If you continue they will be saved automatically and reopened. Continue?
4	EditorReopener_ShouldSave_Title=Unsaved editors need reopening
5	NullDocCommentOwner_Name=None




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import java.net.URL;

import org.eclipse.core.runtime.Assert;

import org.eclipse.cdt.ui.text.doctools.IDocCommentSimpleDictionary;

import org.eclipse.cdt.internal.ui.text.spelling.engine.AbstractSpellDictionary;
import org.eclipse.cdt.internal.ui.text.spelling.engine.ISpellDictionary;

/**
 * Adapter from interim public {@link IDocCommentSimpleDictionary} to internal {@link ISpellDictionary}
 */
public class DocCommentSpellDictionary extends AbstractSpellDictionary {

	protected IDocCommentSimpleDictionary fDict;
	
	/**
	 * @param dict
	 */
	public DocCommentSpellDictionary(IDocCommentSimpleDictionary dict) {
		Assert.isNotNull(dict);
		fDict= dict;
	}
	
	/*
	 * @see org.eclipse.cdt.internal.ui.text.spelling.engine.AbstractSpellDictionary#getName()
	 */
	protected final URL getURL() {
		return null;
	}

	/*
	 * @see org.eclipse.cdt.ui.text.spelling.engine.AbstractSpellDictionary#load(java.net.URL)
	 */
	protected synchronized boolean load(final URL url) {
		unload();

		String[] words= fDict.getAdditionalWords();
		for(int i=0; i<words.length; i++)
			hashWord(words[i]);
		
		return false;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextDoubleClickStrategy;

import org.eclipse.cdt.ui.text.ICTokenScanner;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;
import org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer;
import org.eclipse.cdt.ui.text.doctools.IDocCommentDictionary;
import org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration;

public class NullDocCommentViewerConfiguration implements IDocCommentViewerConfiguration {
	public static final IDocCommentViewerConfiguration INSTANCE= new NullDocCommentViewerConfiguration();
	
	public NullDocCommentViewerConfiguration() {
	}
	
	public IAutoEditStrategy createAutoEditStrategy() {		
		return null;
	}

	public ICTokenScanner createCommentScanner(ITokenStoreFactory tokenStoreFactory) {
		return null;
	}

	public ITextDoubleClickStrategy createDoubleClickStrategy() {
		return null;
	}

	public ICompletionProposalComputer createProposalComputer() {
		return null;
	}

	public boolean isDocumentationComment(IDocument doc, int offset, int length) {
		return false;
	}
	
	public IDocCommentDictionary getSpellingDictionary() {
		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.dialogs;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Link;
import org.eclipse.ui.dialogs.PreferencesUtil;

import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
import org.eclipse.cdt.utils.ui.controls.ControlFactory;

import org.eclipse.cdt.internal.ui.text.doctools.DocCommentOwnerManager;

/**
 * Project property page for setting documentation comment owner.
 */
public class DocCommentOwnerBlock extends AbstractCOptionPage {
	private static String EDITOR_PREF_PAGE_ID= "org.eclipse.cdt.ui.preferences.CEditorPreferencePage"; //$NON-NLS-1$
	DocCommentOwnerComposite fDocComboComposite;
	DocCommentOwnerManager fManager;
	
	Button fCheckbox;
	Link fLink;
	
	public DocCommentOwnerBlock() {
		fManager= DocCommentOwnerManager.getInstance();
	}
	
	void handleCheckBox() {
		fDocComboComposite.setEnabled(fCheckbox.getSelection());
		fLink.setVisible(!fCheckbox.getSelection());
	}
	
	public void createControl(final Composite parent) {
		Composite pane= new Composite(parent, SWT.NONE);
		pane.setLayout(new GridLayout(2, true));
		pane.setLayoutData(GridDataFactory.fillDefaults().grab(true,false).span(2, 1).create());
		
		setControl(pane);
		
		fCheckbox= ControlFactory.createCheckBox(pane, DialogsMessages.DocCommentOwnerBlock_EnableProjectSpecificSettings);
		fCheckbox.setLayoutData(GridDataFactory.fillDefaults().grab(true,false).create());
		fCheckbox.addSelectionListener(new SelectionAdapter(){
			public void widgetSelected(SelectionEvent e) {
				handleCheckBox();
			}
		});
		
		fLink= new Link(pane, SWT.NONE);
		fLink.setText(DialogsMessages.PreferenceScopeBlock_preferenceLink);
		fLink.setLayoutData(GridDataFactory.fillDefaults().align(GridData.CENTER, GridData.BEGINNING).grab(true,false).create());
		fLink.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				PreferencesUtil.createPreferenceDialogOn(parent.getShell(), EDITOR_PREF_PAGE_ID, null, null).open();
			}
		});
		
		String dsc= DialogsMessages.DocCommentOwnerBlock_SelectDocToolDescription;
		String msg= DialogsMessages.DocCommentOwnerBlock_DocToolLabel;
		
		IDocCommentOwner prjOwner= DocCommentOwnerManager.getInstance().getCommentOwner(getProject());
		fDocComboComposite= new DocCommentOwnerComposite(pane, prjOwner, dsc, msg);
		fDocComboComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true,false).span(2, 1).create());
		
		fCheckbox.setSelection(fManager.projectDefinesOwnership(getProject()));
		handleCheckBox();
	}
	
	public void performApply(IProgressMonitor monitor) throws CoreException {
		if(!fCheckbox.getSelection())
			fManager.setCommentOwner(getProject(), null, true);
		else {
			IDocCommentOwner newOwner= fDocComboComposite.getSelectedDocCommentOwner();
			IProject p= getProject();
			fManager.setCommentOwner(p, newOwner, true);
		}
	}

	public IProject getProject() {
		ICOptionContainer container = getContainer();
		if (container != null){
			if (container instanceof ICOptionContainerExtension) {
				try {
					return ((ICOptionContainerExtension) container).getProjectHandle();
				}
				catch (Exception e) {
					return null;
				}
			}
			return container.getProject();
		}
		return null;
	}

	public void performDefaults() {
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.text.doctools.generic;

import org.eclipse.jface.text.ITextDoubleClickStrategy;

import org.eclipse.cdt.ui.text.ICTokenScanner;
import org.eclipse.cdt.ui.text.ITokenStoreFactory;
import org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer;
import org.eclipse.cdt.ui.text.doctools.IDocCommentDictionary;
import org.eclipse.cdt.ui.text.doctools.IDocCommentSimpleDictionary;
import org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration;

/**
 * An abstract base-class for documentation tool contributions using the 'generic tag' framework
 */
public abstract class AbstractGenericTagDocCommentViewerConfiguration implements IDocCommentViewerConfiguration {
	protected GenericDocTag[] fTags;
	protected char[] fTagMarkers;
	
	protected ITextDoubleClickStrategy fDCStrategy;
	protected ICompletionProposalComputer fCPComputer;
	protected String fDefaultToken;
	protected String fTagToken;
	protected IDocCommentSimpleDictionary fDictionary;
	
	/**
	 * 
	 * @param tags a non-null array of tags this configuration should recognize
	 * @param tagMarkers a non-null array of characters used to prefix the tags (e.g. @ or \)
	 * @param defaultToken the default scanner token id
	 * @param tagToken the scanner token to use to mark used by this configuration
	 */
	public AbstractGenericTagDocCommentViewerConfiguration(GenericDocTag[] tags, char[] tagMarkers, String defaultToken, String tagToken) {
		fTags= tags;
		fTagMarkers= tagMarkers;
		fDCStrategy= new GenericTagDoubleClickStrategy(tagMarkers);
		fCPComputer= new GenericTagCompletionProposalComputer(fTags);
		fDefaultToken= defaultToken;
		fTagToken= tagToken;
		fDictionary= new GenericTagSimpleDictionary(fTagMarkers, fTags);
	}

	/*
	 * @see org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration#createCommentScanner(org.eclipse.cdt.ui.text.ITokenStoreFactory, java.lang.String)
	 */
	public ICTokenScanner createCommentScanner(ITokenStoreFactory tokenStoreFactory) {
		return new GenericTagCommentScanner(tokenStoreFactory, fDefaultToken, fTagToken, fTags, fTagMarkers);
	}

	/*
	 * @see org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration#createDoubleClickStrategy()
	 */
	public ITextDoubleClickStrategy createDoubleClickStrategy() {
		return fDCStrategy;
	}

	/*
	 * @see org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration#createProposalComputer()
	 */
	public ICompletionProposalComputer createProposalComputer() {
		return fCPComputer;
	}
	
	/*
	 * @see org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration#getSpellingDictionary()
	 */
	public IDocCommentDictionary getSpellingDictionary() {
		return fDictionary;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.dialogs;

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

import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;

import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
import org.eclipse.cdt.utils.ui.controls.ControlFactory;

import org.eclipse.cdt.internal.ui.text.doctools.DocCommentOwnerManager;
import org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentOwner;

/**
 * Manages the population and selection of the doc-comment {@link Combo} box
 */
public class DocCommentOwnerCombo extends Composite {
	protected Combo fCombo;
	protected IDocCommentOwner fOwners[], fInitialOwner;

	public DocCommentOwnerCombo(Composite parent, int style, IDocCommentOwner initialOwner) {
		super(parent, style);
		setLayout(new GridLayout());
		fInitialOwner= initialOwner;
		fOwners= getNontestOwners();
		createControl(this);
	}

	public IDocCommentOwner getSelectedDocCommentOwner() {
		int index= fCombo.getSelectionIndex();
		return index == 0 ? NullDocCommentOwner.INSTANCE : fOwners[index-1];
	}
	
	/**
	 * @return the list of registered doc-comment owners, filtering out those from the
	 * test plug-in.
	 */
	private static IDocCommentOwner[] getNontestOwners() {
		IDocCommentOwner[] prefilter= DocCommentOwnerManager.getInstance().getRegisteredOwners();
		List result= new ArrayList();
		for(int i=0; i<prefilter.length; i++) {
			if(prefilter[i].getID().indexOf(".test.")==-1) //$NON-NLS-1$
				result.add(prefilter[i]);
		}
		return (IDocCommentOwner[]) result.toArray(new IDocCommentOwner[result.size()]);
	}
	
	public void createControl(Composite parent) {
		String[] items= new String[fOwners.length+1];
		items[0]= DialogsMessages.DocCommentOwnerCombo_None;
		for(int i=0; i<fOwners.length; i++) {
			items[i+1]= fOwners[i].getName();
		}
		fCombo = ControlFactory.createSelectCombo(parent, items, DialogsMessages.DocCommentOwnerCombo_None);
		selectInCombo(fInitialOwner);
	}

	public void selectInCombo(IDocCommentOwner owner) {
		for(int i=0; i<fOwners.length; i++) {
			if(fOwners[i].getID().equals(owner.getID())) {
				fCombo.select(i+1);
				return;
			}
		}
		fCombo.select(0);
	}
	
	public void setEnabled(boolean enabled) {
		fCombo.setEnabled(enabled);
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.text.doctools;

import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
import org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration;


public class DocCommentMultilineProposalComputer extends AbstractDocCommentProposalComputer {
	protected IDocCommentViewerConfiguration getConfiguration(IDocCommentOwner owner) {
		return owner.getMultilineConfiguration();
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * 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

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.core.internal.filebuffers;


import java.util.List;
import java.util.Map;

import org.eclipse.core.filebuffers.IAnnotationModelFactory;
import org.eclipse.core.filebuffers.IDocumentFactory;
import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
import org.eclipse.core.filebuffers.IDocumentSetupParticipantExtension;
import org.eclipse.core.filebuffers.IFileBuffer;
import org.eclipse.core.filebuffers.IFileBufferListener;
import org.eclipse.core.filebuffers.IFileBufferStatusCodes;
import org.eclipse.core.filebuffers.ISynchronizationContext;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileInfo;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.filesystem.URIUtil;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.content.IContentDescription;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.core.runtime.content.IContentTypeManager;

import org.eclipse.core.filebuffers.IAnnotationModelFactory;
import org.eclipse.core.filebuffers.IDocumentFactory;
import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
import org.eclipse.core.filebuffers.IFileBuffer;
import org.eclipse.core.filebuffers.IFileBufferListener;
import org.eclipse.core.filebuffers.IFileBufferStatusCodes;
import org.eclipse.core.filebuffers.ISynchronizationContext;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.filebuffers.LocationKind;

import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentExtension4;
import org.eclipse.jface.text.source.IAnnotationModel;

	 * @see org.eclipse.core.filebuffers.ITextFileBufferManager#createEmptyDocument(org.eclipse.core.runtime.IPath, org.eclipse.core.filebuffers.LocationKind)
	 * @since 3.3
	 */
	public IDocument createEmptyDocument(final IPath location, final LocationKind locationKind) {
		final IDocument[] runnableResult= new IDocument[1];
		if (location != null) {
			final IDocumentFactory factory= fRegistry.getDocumentFactory(location, locationKind);

				final IDocumentSetupParticipant participant= participants[i];
				ISafeRunnable runnable= new ISafeRunnable() {
					public void run() throws Exception {
						if(participant instanceof IDocumentSetupParticipantExtension) {
							IDocumentSetupParticipantExtension extParticipant= (IDocumentSetupParticipantExtension) participant;
							extParticipant.setup(document, location, locationKind);
						} else {
							participant.setup(document);
						}
						if (document.getDocumentPartitioner() != null) {
							String message= NLSUtility.format(FileBuffersMessages.TextFileBufferManager_warning_documentSetupInstallsDefaultPartitioner, participant.getClass());
							IStatus status= new Status(IStatus.WARNING, FileBuffersPlugin.PLUGIN_ID, IStatus.OK, message, null);




/*******************************************************************************
 * Copyright (c) 2007, 2008 IBM Corporation and others.
 * 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

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.core.internal.filebuffers;

import java.util.ArrayList;

import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.filebuffers.IAnnotationModelFactory;
import org.eclipse.core.filebuffers.IDocumentFactory;
import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
import org.eclipse.core.filebuffers.IDocumentSetupParticipantExtension;
import org.eclipse.core.filebuffers.IFileBuffer;
import org.eclipse.core.filebuffers.IStateValidationSupport;
import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceRuleFactory;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.preferences.IScopeContext;
import org.eclipse.core.runtime.preferences.InstanceScope;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceRuleFactory;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.filebuffers.IAnnotationModelFactory;
import org.eclipse.core.filebuffers.IDocumentFactory;
import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
import org.eclipse.core.filebuffers.IFileBuffer;
import org.eclipse.core.filebuffers.IStateValidationSupport;
import org.eclipse.core.filebuffers.LocationKind;

import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentExtension4;
import org.eclipse.jface.text.source.IAnnotationModel;

		return null;
	}

	public IDocument createEmptyDocument(final IFile file) {
		final IDocument[] runnableResult= new IDocument[1];
		final IDocumentFactory factory= ((ResourceExtensionRegistry)fRegistry).getDocumentFactory(file);
		if (factory != null) {

				final IDocumentSetupParticipant participant= participants[i];
				ISafeRunnable runnable= new ISafeRunnable() {
					public void run() throws Exception {
						if(participant instanceof IDocumentSetupParticipantExtension) {
							IDocumentSetupParticipantExtension ext= (IDocumentSetupParticipantExtension) participant;
							IPath path= file == null ? null : file.getFullPath();
							ext.setup(document, path, LocationKind.IFILE);
						} else {
							participant.setup(document);
						}
						if (document.getDocumentPartitioner() != null) {
							String message= NLSUtility.format(FileBuffersMessages.TextFileBufferManager_warning_documentSetupInstallsDefaultPartitioner, participant.getClass());
							IStatus status= new Status(IStatus.WARNING, FileBuffersPlugin.PLUGIN_ID, IStatus.OK, message, null);

Lines 1-5 Link Here

(-)src/org/eclipse/core/filebuffers/IDocumentSetupParticipant.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 29-34 Link Here
29	*	29	*
30	* @since 3.0	30	* @since 3.0
31	* @see org.eclipse.jface.text.IDocumentExtension3	31	* @see org.eclipse.jface.text.IDocumentExtension3
		32	* @see org.eclipse.core.filebuffers.IDocumentSetupParticipantExtension
32	*/	33	*/
33	public interface IDocumentSetupParticipant {	34	public interface IDocumentSetupParticipant {
34		35




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.core.filebuffers;

import org.eclipse.core.runtime.IPath;
import org.eclipse.jface.text.IDocument;

/**
 * Extension interface for {@link org.eclipse.core.filebuffers.IDocumentSetupParticipant}.<p>
 * 
 * This interface is additionally implemented by {@link IDocumentSetupParticipant}'s which
 * would like to alter their behavior based on the location of the file being opened.<p>
 * 
 * Note that when participants implement this interface, the original method from
 * {@link IDocumentSetupParticipant} will never be called.
 * 
 * @see org.eclipse.core.filebuffers.IDocumentSetupParticipant
 * @since 3.4
 */
public interface IDocumentSetupParticipantExtension {

	/**
	 * Sets up the document to be ready for use by a text file buffer.
	 *
	 * @param document the document to be set up
	 * @param location a path of the resource backing the new document. May be null.
	 * @param locationKind the LocationKind of the location specified. May be null.
	 */
	void setup(IDocument document, IPath location, LocationKind locationKind);
}

Lines 51-56 Link Here

(-)suite/org/eclipse/cdt/core/testplugin/util/TestSourceReader.java (-2 / +5 lines)
51	import org.eclipse.core.runtime.Path;	51	import org.eclipse.core.runtime.Path;
52	import org.osgi.framework.Bundle;	52	import org.osgi.framework.Bundle;
53		53
		54	/**
		55	* Utilities for reading test source code from plug-in .java sources
		56	*/
54	public class TestSourceReader {	57	public class TestSourceReader {
55		58
56	/**	59	/**
Lines 85-91 Link Here
85	List contents = new ArrayList();	88	List contents = new ArrayList();
86	StringBuffer content = new StringBuffer();	89	StringBuffer content = new StringBuffer();
87	for(String line = br.readLine(); line!=null; line = br.readLine()) {	90	for(String line = br.readLine(); line!=null; line = br.readLine()) {
88	line = line.trim();	91	line = line.replaceFirst("^\\s*", ""); // replace leading whitespace, preserve trailing
89	if(line.startsWith("//")) {	92	if(line.startsWith("//")) {
90	content.append(line.substring(2)+"\n");	93	content.append(line.substring(2)+"\n");
91	} else {	94	} else {
Lines 113-119 Link Here
113	* @param lookfor string to be searched for	116	* @param lookfor string to be searched for
114	* @param fullPath full path of the workspace file	117	* @param fullPath full path of the workspace file
115	* @return the offset or -1	118	* @return the offset or -1
116	* @throws CoreException	119	* @throws Exception
117	* @throws UnsupportedEncodingException	120	* @throws UnsupportedEncodingException
118	* @since 4.0	121	* @since 4.0
119	*/	122	*/

Lines 13-18 Link Here

(-)ui/org/eclipse/cdt/ui/tests/text/TextTestSuite.java (+5 lines)
13		13
14	import junit.framework.TestSuite;	14	import junit.framework.TestSuite;
15		15
		16	import org.eclipse.cdt.ui.tests.text.doctools.DocCommentTestSuite;
		17
16	public class TextTestSuite extends TestSuite {	18	public class TextTestSuite extends TestSuite {
17		19
18	public static TestSuite suite() {	20	public static TestSuite suite() {
Lines 22-27 Link Here
22	public TextTestSuite() {	24	public TextTestSuite() {
23	super(TextTestSuite.class.getName());	25	super(TextTestSuite.class.getName());
24		26
		27	// documentation tool extension tests
		28	addTest(DocCommentTestSuite.suite());
		29
25	// partitioning tests	30	// partitioning tests
26	addTest(PartitionTokenScannerTest.suite());	31	addTest(PartitionTokenScannerTest.suite());
27	addTest(CPartitionerTest.suite());	32	addTest(CPartitionerTest.suite());




 * Contributors:
 *     Anton Leherbauer (Wind River Systems) - initial API and implementation
 *     Sergey Prigogin, Google
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/

package org.eclipse.cdt.ui.tests.text;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.core.runtime.Plugin;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.DocumentCommand;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.TextUtilities;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.testplugin.util.BaseTestCase;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.ICPartitions;
import org.eclipse.cdt.ui.text.doctools.DefaultMultilineCommentAutoEditStrategy;

import org.eclipse.cdt.internal.formatter.DefaultCodeFormatterOptions;

import org.eclipse.cdt.internal.ui.text.CAutoIndentStrategy;
import org.eclipse.cdt.internal.ui.text.CCommentAutoIndentStrategy;
import org.eclipse.cdt.internal.ui.text.CTextTools;

/**
 * Testing the auto indent strategies.
 */
public class CAutoIndentTest extends AbstractAutoEditTest {

	/**
	 * Helper class to test the auto-edit strategies on a document.
	 */
	static class AutoEditTester {

		private Map fStrategyMap = new HashMap();
		private IDocument fDoc;
		private String fPartitioning;
		private int fCaretOffset;

		public AutoEditTester(IDocument doc, String partitioning) {
			super();
			fDoc = doc;
			fPartitioning = partitioning;
		}

		public void setAutoEditStrategy(String contentType, IAutoEditStrategy aes) {
			fStrategyMap.put(contentType, aes);
		}

		public IAutoEditStrategy getAutoEditStrategy(String contentType) {
			return (IAutoEditStrategy)fStrategyMap.get(contentType);
		}

		/**
		 * Empties the document, and returns the caret to the origin (0,0)
		 */
		public void reset() {
			try {
				goTo(0,0);
				fDoc.set("");
			} catch(BadLocationException ble) {
				fail(ble.getMessage());
			}
		}
		
		public void type(String text) throws BadLocationException {
			for (int i = 0; i < text.length(); ++i) {
				type(text.charAt(i));
			}
		}

		public void type(char c) throws BadLocationException {
			TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, new String(new char[] { c }));
			customizeDocumentCommand(command);
			fCaretOffset = command.exec(fDoc);
		}

		private void customizeDocumentCommand(TestDocumentCommand command) throws BadLocationException {
			IAutoEditStrategy aes = getAutoEditStrategy(getContentType());
			if (aes != null) {
				aes.customizeDocumentCommand(fDoc, command);
			}
		}

		public void type(int offset, String text) throws BadLocationException {
			fCaretOffset = offset;
			type(text);
		}

		public void type(int offset, char c) throws BadLocationException {
			fCaretOffset = offset;
			type(c);
		}

		public void paste(String text) throws BadLocationException {
			TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, text);
			customizeDocumentCommand(command);
			fCaretOffset = command.exec(fDoc);
		}

		public void paste(int offset, String text) throws BadLocationException {
			fCaretOffset = offset;
			paste(text);
		}

		public void backspace(int n) throws BadLocationException {
			for (int i = 0; i < n; ++i) {
				backspace();
			}
		}
		
		public void backspace() throws BadLocationException {
			TestDocumentCommand command = new TestDocumentCommand(fCaretOffset - 1, 1, ""); //$NON-NLS-1$
			customizeDocumentCommand(command);
			fCaretOffset = command.exec(fDoc);
		}

		public int getCaretOffset() {
			return fCaretOffset;
		}

		public int setCaretOffset(int offset) {
			fCaretOffset = offset;
			if (fCaretOffset < 0)
				fCaretOffset = 0;
			else if (fCaretOffset > fDoc.getLength())
				fCaretOffset = fDoc.getLength();
			return fCaretOffset;
		}
		
		/**
		 * Moves caret right or left by the given number of characters.
		 * 
		 * @param shift Move distance.
		 * @return New caret offset.
		 */
		public int moveCaret(int shift) {
			return setCaretOffset(fCaretOffset + shift);
		}
		
		public int goTo(int line) throws BadLocationException {
			fCaretOffset = fDoc.getLineOffset(line);
			return fCaretOffset;
		}

		public int goTo(int line, int column) throws BadLocationException {
			if (column < 0 || column > fDoc.getLineLength(line)) {
				throw new BadLocationException("No column " + column + " in line " + line); //$NON-NLS-1$ $NON-NLS-2$
			}
			fCaretOffset = fDoc.getLineOffset(line) + column;
			return fCaretOffset;
		}

		public int getCaretLine() throws BadLocationException {
			return fDoc.getLineOfOffset(fCaretOffset);
		}

		public int getCaretColumn() throws BadLocationException {
			IRegion region = fDoc.getLineInformationOfOffset(fCaretOffset);
			return fCaretOffset - region.getOffset();
		}

		public char getChar() throws BadLocationException {
			return getChar(0);
		}
		
		public char getChar(int i) throws BadLocationException {
			return fDoc.getChar(fCaretOffset+i);
		}
		
		public String getLine() throws BadLocationException {
			return getLine(0);
		}

		public String getLine(int i) throws BadLocationException {
			IRegion region = fDoc.getLineInformation(getCaretLine() + i);
			return fDoc.get(region.getOffset(), region.getLength());
		}

		public String getContentType() throws BadLocationException {
			return getContentType(0);
		}

		public String getContentType(int i) throws BadLocationException {
			return TextUtilities.getContentType(fDoc, fPartitioning, fCaretOffset + i, false);
		}
	}

	/**
	 * A DocumentCommand with public constructor and exec method.
	 */
	static class TestDocumentCommand extends DocumentCommand {

		public TestDocumentCommand(int offset, int length, String text) {
			super();
			doit = true;
			this.text = text;

			this.offset = offset;
			this.length = length;

			owner = null;
			caretOffset = -1;
		}

		/**
		 * Returns new caret position.
		 */
		public int exec(IDocument doc) throws BadLocationException {
			doc.replace(offset, length, text);
			return caretOffset != -1 ?
						caretOffset :
						offset + (text == null ? 0 : text.length());
		}
	}

	private HashMap fOptions;
	private List fStatusLog;

		IDocument doc = new Document();
		textTools.setupCDocument(doc);
		AutoEditTester tester = new AutoEditTester(doc, ICPartitions.C_PARTITIONING);
		
		tester.setAutoEditStrategy(IDocument.DEFAULT_CONTENT_TYPE, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));
		tester.setAutoEditStrategy(ICPartitions.C_MULTI_LINE_COMMENT, new DefaultMultilineCommentAutoEditStrategy());
		tester.setAutoEditStrategy(ICPartitions.C_PREPROCESSOR, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));
		return tester;
	}

	public void testCCommentAutoIndent() throws BadLocationException {
		AutoEditTester tester = createAutoEditTester(); //$NON-NLS-1$
		tester.type("/*\n"); //$NON-NLS-1$
		assertEquals(ICPartitions.C_MULTI_LINE_COMMENT, tester.getContentType(tester.getCaretOffset()-1));
		assertEquals(1, tester.getCaretLine());
		assertEquals(3, tester.getCaretColumn());
		assertEquals(" * ", tester.getLine()); //$NON-NLS-1$

Lines 1-5 Link Here

(-)ui/org/eclipse/cdt/ui/tests/text/PartitionTokenScannerTest.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2006 QNX Software Systems and others.	2	* Copyright (c) 2005, 2008 QNX Software Systems and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 41-47 Link Here
41		41
42	protected void setUp() {	42	protected void setUp() {
43	fReference= new CPartitionScanner();	43	fReference= new CPartitionScanner();
44	fTestee= new FastCPartitionScanner(true);	44	fTestee= new FastCPartitionScanner(true, null);
45	}	45	}
46		46
47	// read sample C file	47	// read sample C file

Lines 49-55 Link Here

(-)ui/org/eclipse/cdt/ui/tests/text/CPartitionerTest.java (-1 / +1 lines)
49	fTextTools= new CTextTools(new PreferenceStore());	49	fTextTools= new CTextTools(new PreferenceStore());
50		50
51	fDocument= new Document();	51	fDocument= new Document();
52	IDocumentPartitioner partitioner= fTextTools.createDocumentPartitioner();	52	IDocumentPartitioner partitioner= fTextTools.createDocumentPartitioner(null);
53	partitioner.connect(fDocument);	53	partitioner.connect(fDocument);
54	fDocument.setDocumentPartitioner(partitioner);	54	fDocument.setDocumentPartitioner(partitioner);
55	fDocument.set("xxx\n/xxx/\nxxx\n/*xxx/\nxxx\n//\nxxx\n/*/\nxxx");	55	fDocument.set("xxx\n/xxx/\nxxx\n/*xxx/\nxxx\n//\nxxx\n/*/\nxxx");

Lines 209-215 Link Here

(-)ui/org/eclipse/cdt/ui/tests/text/CodeFormatterTest.java (-1 / +1 lines)
209		209
210	//int verylooooooooooooooooooooooooooooooooooongname = 0000000000000000000000000000000;	210	//int verylooooooooooooooooooooooooooooooooooongname = 0000000000000000000000000000000;
211		211
212	//int verylooooooooooooooooooooooooooooooooooongname =	212	//int verylooooooooooooooooooooooooooooooooooongname =
213	// 0000000000000000000000000000000;	213	// 0000000000000000000000000000000;
214	public void testLineWrappingOfInitializerExpression_Bug200961() throws Exception {	214	public void testLineWrappingOfInitializerExpression_Bug200961() throws Exception {
215	assertFormatterResult();	215	assertFormatterResult();




      <perspectiveExtension
            targetID="org.eclipse.ui.resourcePerspective">
         <view
               id="org.eclipse.cdt.ui.tests.DOMAST.DOMAST"
               ratio="0.5"
               relative="org.eclipse.ui.views.TaskList"
               relationship="right"
               relative="org.eclipse.ui.views.TaskList">
         </view>
      </perspectiveExtension>
   </extension>

            projectType="org.eclipse.cdt.build.core.buildArtefactType.exe">
      </template>
   </extension>
   
   
   <!-- documentation tool comment test owners -->
   <extension
         point="org.eclipse.cdt.ui.DocCommentOwner">
     <owner id="org.cdt.test.DCOM1"
         name="Test comment owner1"
         singleline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
         multiline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
     />
   </extension>
    <extension
         point="org.eclipse.cdt.ui.DocCommentOwner">
      <owner  id="org.cdt.test.DCOM2"
         name="Test comment owner1"
           singleline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
         multiline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
         />
   </extension>
    <extension
          point="org.eclipse.cdt.ui.DocCommentOwner">
       <owner
             id="org.cdt.test.DCOM3"
             multiline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
             name="Test comment owner1"
             singleline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration">
       </owner>
    </extension>
    <extension
          point="org.eclipse.cdt.ui.DocCommentOwner">
       <owner
             id="org.cdt.test.ownerA"
             multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$A"
             name="name_A"
             singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$A">
       </owner>
    </extension>
      <extension
          point="org.eclipse.cdt.ui.DocCommentOwner">
       <owner
             id="org.cdt.test.ownerB"
             multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$B"
             name="name_B"
             singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$B">
       </owner>
    </extension>
      <extension
          point="org.eclipse.cdt.ui.DocCommentOwner">
       <owner
             id="org.cdt.test.ownerC"
             multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$C"
             name="name_C"
             singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$C">
       </owner>
    </extension>
    <extension
          point="org.eclipse.cdt.ui.DocCommentOwner">
       <owner
             id="org.cdt.test.ownerABC"
             multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$ABC"
             name="name_ABC"
             singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$ABC">
       </owner>
    </extension>
    <extension
          point="org.eclipse.cdt.ui.DocCommentOwner">
       <owner
             id="org.cdt.test.ownerBDFG"
             multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$BDFG"
             name="name_BDFG"
             singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$BDFG">
       </owner>
    </extension>
    <extension
          point="org.eclipse.cdt.ui.DocCommentOwner">
       <owner
             id="org.cdt.test.ownerPUNC"
             multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$PUNC"
             name="name_PUNC"
             singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$PUNC">
       </owner>
    </extension>
    
</plugin>




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.tests.text.doctools;

import junit.framework.TestSuite;

public class DocCommentTestSuite extends TestSuite {

    public static TestSuite suite() {
        return new DocCommentTestSuite();
    }
    
    public DocCommentTestSuite() {
        super(DocCommentTestSuite.class.getName());

        // partitioning tests
		addTest(CommentOwnerManagerTests.suite());
		addTest(DocCommentHighlightingTest.suite());
    }
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.tests.text.doctools;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.swt.graphics.RGB;

import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.text.doctools.generic.AbstractGenericTagDocCommentViewerConfiguration;
import org.eclipse.cdt.ui.text.doctools.generic.GenericDocTag;

import org.eclipse.cdt.internal.ui.text.doctools.docpp.DocppHelper;

public class TestGenericTagConfiguration extends AbstractGenericTagDocCommentViewerConfiguration {
	public static final RGB DEFAULTRGB= new RGB(63, 95, 191);
	
	protected char[] fCommentMarkers;
	
	public TestGenericTagConfiguration(String commentMarkers, String tags, String tagMarkers, String defaultToken, String tagToken) {
		super(mkTags(tags.split("(\\s)*,(\\s)*")), tagMarkers.toCharArray(), defaultToken, tagToken);
		IPreferenceStore cuis= CUIPlugin.getDefault().getPreferenceStore();
		PreferenceConverter.setDefault(cuis, defaultToken, DEFAULTRGB);
		PreferenceConverter.setDefault(cuis, tagToken, new RGB(127, 159, 191));
		fCommentMarkers= commentMarkers.toCharArray();
	}
	
	public IAutoEditStrategy createAutoEditStrategy() {
		return null;
	}
	
	private static GenericDocTag[] mkTags(String[] tagNames) {
		GenericDocTag[] tags= new GenericDocTag[tagNames.length];
		for(int i=0; i<tagNames.length; i++) {
			tags[i]= new GenericDocTag(tagNames[i], "no description");
		}
		return tags;
	}
	
	public boolean isDocumentationComment(IDocument doc, int offset, int length) {
		try {
			if(offset+2 < doc.getLength()) {
				char c= doc.getChar(offset+2);
				for(int i=0; i<fCommentMarkers.length; i++)
					if(c == fCommentMarkers[i])
						return true;
				return false;
			}
		} catch(BadLocationException ble) {
			CUIPlugin.getDefault().log(ble);
		}
		return false;
	}
	
	public static class A extends TestGenericTagConfiguration {
		public A() {super("A", "", "@", "test.token.A.default", "test.token.A.tag");}
	}
	
	public static class B extends TestGenericTagConfiguration {
		public B() {super("B", "", "@", "test.token.B.default", "test.token.B.tag");}
	}
	
	public static class C extends TestGenericTagConfiguration {
		public C() {super("C", "", "@", "test.token.C.default", "test.token.C.tag");}
	}
	
	public static class ABC extends TestGenericTagConfiguration {
		public ABC() {super("ABC", "", "@", "test.token.ABC.default", "test.token.ABC.tag");}
	}
	
	public static class BDFG extends TestGenericTagConfiguration {
		public BDFG() {super("BDFG", "", "@", "test.token.BDFG.default", "test.token.BDFG.tag");}
	}
	
	public static class PUNC extends TestGenericTagConfiguration {
		public PUNC() {super("!*#", "", "@", "test.token.BDFG.default", "test.token.BDFG.tag");}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/

package org.eclipse.cdt.ui.tests.text.doctools;

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

import junit.framework.Assert;
import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.texteditor.AbstractTextEditor;

import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.testplugin.CProjectHelper;
import org.eclipse.cdt.ui.tests.BaseUITestCase;
import org.eclipse.cdt.ui.tests.text.Accessor;
import org.eclipse.cdt.ui.tests.text.EditorTestHelper;
import org.eclipse.cdt.ui.tests.text.ResourceTestHelper;

import org.eclipse.cdt.internal.ui.editor.CEditor;
import org.eclipse.cdt.internal.ui.text.doctools.DocCommentOwnerManager;

/**
 * 
 * @author andrewferguson
 */
public class DocCommentHighlightingTest extends BaseUITestCase {
	private static final DocCommentOwnerManager DCMAN= DocCommentOwnerManager.getInstance();
	private static final String LINKED_FOLDER= "resources/docComments";
	private static final String PROJECT= "DocCommentTests";

	// ordered by occurrence
	private static final int[] normal0= {114, 13};
	private static final int[] comment1= {129, 18};
	private static final int[] comment2= {149, 17};
	private static final int[] comment3= {168, 16};
	private static final int[] comment4= {184, 18};
	private static final int[] comment5= {204, 19};
	private static final int[] comment6= {223, 16};
	private static final int[] comment7= {241, 17};
	private static final int[] comment8= {258, 16};
	private static final int[] comment9= {274, 17};
	private static final int[] comment10= {293, 18};
	private static final int[] snormal0= {315, 13};
	private static final int[] scomment1= {328, 17};
	private static final int[] scomment2= {345, 16};
	private static final int[] scomment3= {361, 17};
	private static final int[] scomment4= {378, 16};
	private static final int[] scomment5= {394, 18};
	private static final int[] comment11= {414, 18};
	private static final int[] scomment6= {433, 16};
	private static final int[] comment12= {449, 19};
	private static final int[] scomment7= {469, 17};
	
	
	private ICProject fCProject;
	private final String fTestFilename= "/"+PROJECT+"/src/this.cpp";

	private static SourceViewer fSourceViewer;

	public static Test suite() {
		return new TestSuite(DocCommentHighlightingTest.class);
	}

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

	protected void setUp() throws Exception {
		super.setUp();
		fCProject= EditorTestHelper.createCProject(PROJECT, LINKED_FOLDER);

		AbstractTextEditor fEditor= (CEditor) EditorTestHelper.openInEditor(ResourceTestHelper.findFile(fTestFilename), true);
		fSourceViewer= EditorTestHelper.getSourceViewer(fEditor);
		assertTrue(EditorTestHelper.joinReconciler(fSourceViewer, 0, 10000, 100));
	}

	protected void tearDown () throws Exception {
		EditorTestHelper.closeAllEditors();

		if (fCProject != null)
			CProjectHelper.delete(fCProject);

		super.tearDown();
	}

	protected List/*<Position>*/ findRangesColored(RGB rgb) {
		List result= new ArrayList();
		System.out.println("-------------");
		IEditorPart p= get();
		ISourceViewer vw= ((CEditor)p).getViewer();
		Accessor a= new Accessor(vw, TextViewer.class);
		StyledText st= (StyledText) a.get("fTextWidget");
		StyleRange[] rgs= st.getStyleRanges();
		for(int i=0; i<rgs.length; i++) {
			if(rgs[i].foreground != null && rgs[i].foreground.getRGB().equals(rgb)) {
				System.out.println(rgs[i].start +", "+ rgs[i].length);
				result.add(new Position(rgs[i].start, rgs[i].length));
			}
		}
		return result;
	}

	protected IEditorPart get(){
		IWorkbenchWindow window= PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if(window!=null) {
			if(window.getActivePage()!=null) {
				IEditorReference[] es= window.getActivePage().getEditorReferences();
				for(int i=0; i<es.length; i++) {
					IEditorPart part= es[i].getEditor(false);
					if(part != null)
						return part;
				}
			}
		}
		return null;
	}

	private List/*<Position>*/ mkPositions(int[][] raw) {
		List result= new ArrayList();
		for(int i=0; i<raw.length; i++) {
			Assert.assertEquals(2, raw[i].length);
			result.add(new Position(raw[i][0], raw[i][1]));
		}
		return result;
	}
	
	public void testDCOM_A() throws BadLocationException, InterruptedException {
		DCMAN.setCommentOwner(fCProject.getProject(), DCMAN.getOwner("org.cdt.test.ownerA"), true);
		runEventQueue(1000);
		List/*<Position>*/ expected= mkPositions(new int[][] {comment1, scomment1});
		assertEquals(expected, findRangesColored(TestGenericTagConfiguration.DEFAULTRGB));
	}

	public void testDCOM_B() throws BadLocationException, InterruptedException {
		DCMAN.setCommentOwner(fCProject.getProject(), DCMAN.getOwner("org.cdt.test.ownerB"), true);
		runEventQueue(1000);
		List/*<Position>*/ expected= mkPositions(new int[][] {comment2, scomment2});
		assertEquals(expected, findRangesColored(TestGenericTagConfiguration.DEFAULTRGB));
	}

	public void testDCOM_C() throws BadLocationException, InterruptedException  {
		DCMAN.setCommentOwner(fCProject.getProject(), DCMAN.getOwner("org.cdt.test.ownerC"), true);
		runEventQueue(1000);
		List/*<Position>*/ expected= mkPositions(new int[][] {comment3, scomment3});
		assertEquals(expected, findRangesColored(TestGenericTagConfiguration.DEFAULTRGB));
	}

	public void testDCOM_ABC() throws BadLocationException, InterruptedException {
		DCMAN.setCommentOwner(fCProject.getProject(), DCMAN.getOwner("org.cdt.test.ownerABC"), true);
		runEventQueue(1000);
		List/*<Position>*/ expected= mkPositions(new int[][] {comment1, comment2, comment3, scomment1, scomment2, scomment3});
		assertEquals(expected, findRangesColored(TestGenericTagConfiguration.DEFAULTRGB));
	}
	
	public void testDCOM_BDFG() throws BadLocationException, InterruptedException {
		DCMAN.setCommentOwner(fCProject.getProject(), DCMAN.getOwner("org.cdt.test.ownerBDFG"), true);
		runEventQueue(1000);
		List/*<Position>*/ expected= mkPositions(new int[][] {comment2, comment4, comment6, comment7, comment8, scomment2});
		assertEquals(expected, findRangesColored(TestGenericTagConfiguration.DEFAULTRGB));
	}
	
	public void testDCOM_PUNC() throws BadLocationException, InterruptedException {
		DCMAN.setCommentOwner(fCProject.getProject(), DCMAN.getOwner("org.cdt.test.ownerPUNC"), true);
		runEventQueue(1000);
		List/*<Position>*/ expected= mkPositions(new int[][] {comment9, comment10, scomment4, scomment5, comment11, comment12, scomment7});
		assertEquals(expected, findRangesColored(TestGenericTagConfiguration.DEFAULTRGB));
	}
}




/*******************************************************************************
 * Copyright (c) 2006, 2007 Wind River Systems, Inc. and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Anton Leherbauer (Wind River Systems) - initial API and implementation
 *     Sergey Prigogin, Google
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/

package org.eclipse.cdt.ui.tests.text;

import java.io.IOException;
import java.util.HashMap;

import junit.framework.Test;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.testplugin.CProjectHelper;
import org.eclipse.cdt.core.testplugin.util.TestSourceReader;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.testplugin.CTestPlugin;
import org.eclipse.cdt.ui.text.ICPartitions;
import org.eclipse.cdt.ui.text.doctools.DefaultMultilineCommentAutoEditStrategy;

import org.eclipse.cdt.internal.ui.text.CAutoIndentStrategy;
import org.eclipse.cdt.internal.ui.text.CTextTools;


/**
 * Testing the auto indent strategies.
 */
public class DefaultCCommentAutoEditStrategyTest extends AbstractAutoEditTest {
	private HashMap fOptions;

	/**
	 * @param name
	 */
	public DefaultCCommentAutoEditStrategyTest(String name) {
		super(name);
	}

	public static Test suite() {
		return suite(DefaultCCommentAutoEditStrategyTest.class);
	}

	protected void setUp() throws Exception {
		super.setUp();
//		Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();  
//		shell.forceActive();
//		shell.forceFocus();
		fOptions= CCorePlugin.getOptions();
	}

	/*
	 * @see junit.framework.TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {
		CCorePlugin.setOptions(fOptions);
		super.tearDown();
	}

	private AutoEditTester createAutoEditTester() {
		CTextTools textTools = CUIPlugin.getDefault().getTextTools();
		IDocument doc = new Document();
		textTools.setupCDocument(doc);
		AutoEditTester tester = new AutoEditTester(doc, ICPartitions.C_PARTITIONING);


		tester.setAutoEditStrategy(IDocument.DEFAULT_CONTENT_TYPE, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));
		tester.setAutoEditStrategy(ICPartitions.C_MULTI_LINE_COMMENT, new DefaultMultilineCommentAutoEditStrategy());
		tester.setAutoEditStrategy(ICPartitions.C_PREPROCESSOR, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));
		return tester;
	}

	public void testIsMultilineNew() throws BadLocationException {
		DefaultMultilineCommentAutoEditStrategy ds= new DefaultMultilineCommentAutoEditStrategy();
		CTextTools textTools = CUIPlugin.getDefault().getTextTools();
		IDocument doc = new Document();
		textTools.setupCDocument(doc);

		doc.set(" /*  ");
		assertTrue(ds.shouldCloseMultiline(doc, 3));
		doc.set(" /*  \n");
		assertTrue(ds.shouldCloseMultiline(doc, 3));
		assertTrue(ds.shouldCloseMultiline(doc, 5));
		doc.set(" /*  \n  ");
		assertTrue(ds.shouldCloseMultiline(doc, 3));
		assertTrue(ds.shouldCloseMultiline(doc, 6));
		doc.set(" /*  */");
		assertFalse(ds.shouldCloseMultiline(doc, 5));
		doc.set(" /*  */ ");
		assertFalse(ds.shouldCloseMultiline(doc, 5));
		doc.set(" /* \n\n */ ");
		assertFalse(ds.shouldCloseMultiline(doc, 5));
		doc.set(" /* \n\n */ \n /*");
		assertTrue(ds.shouldCloseMultiline(doc, 14));
		doc.set(" /* \n\n */ \n /* ");
		assertTrue(ds.shouldCloseMultiline(doc, 14));
		doc.set(" /* \n\n */ \n /* \n");
		assertTrue(ds.shouldCloseMultiline(doc, 14));
		doc.set(" /* /* \n\n */ \n /* \n");
		assertTrue(ds.shouldCloseMultiline(doc, 3));
		doc.set(" /* \n/* \n\n */ \n /* \n");
		assertTrue(ds.shouldCloseMultiline(doc, 3));
		doc.set(" /* \n\n/* \n\n */ \n /* \n");
		assertTrue(ds.shouldCloseMultiline(doc, 3));
		doc.set(" /* \n\n/* \n\n */ \n /* \n");
		assertTrue(ds.shouldCloseMultiline(doc, 3));
		doc.set(" /* \n\n                 */ /* \n\n */ \n /* \n");
		assertFalse(ds.shouldCloseMultiline(doc, 3));
		doc.set(" /*\n /*\n * \n * \n */\n");
		assertFalse(ds.shouldCloseMultiline(doc, 8));
	}

	// /*X

	// /*
	//  * X
	//  */
	public void testInsertNewLine1() {
		assertNewLineBehaviour();
	}

	//   /*X

	//   /*
	//    * X
	//    */
	public void testInsertNewLine2() {
		assertNewLineBehaviour();
	}	

	// class A {};  /*X

	// class A {};  /*
	// X
	public void testInsertNewLine3() {
		assertNewLineBehaviour();
	}

	// class A {
	// /*X
	// };  

	// class A {
	// /*
	//  * X
	//  */
	// };  
	public void testInsertNewLine4() {
		assertNewLineBehaviour();
	}

	// class A {
	// /* X
	// };  

	// class A {
	// /* 
	//  * X
	//  */
	// };  
	public void testInsertNewLine5() {
		assertNewLineBehaviour();
	}

	
	
	// class A {
	// /*X
	//  * 
	//  */
	// };

	// class A {
	// /*
	//  * X
	//  * 
	//  */
	// };
	public void testInsertNewLine6() {
		assertNewLineBehaviour();
	}

	// class A {
	// /*  
	//  *X
	//  */
	// };

	// class A {
	// /*  
	//  *
	//  *X
	//  */
	// };
	public void testInsertNewLine7() {
		assertNewLineBehaviour();
	}

	// class A {
	// /*  
	//  *X 
	//  */
	// };

	// class A {
	// /*  
	//  *
	//  *X 
	//  */
	// };
	public void testInsertNewLine8() {
		assertNewLineBehaviour();
	}

	// class A {
	// /*  
	//  * abcd def ghiX
	//  */
	// };

	// class A {
	// /*  
	//  * abcd def ghi
	//  * X
	//  */
	// };
	public void testInsertNewLine9() {
		assertNewLineBehaviour();
	}

	// class A {
	// /*  
	//  * abcd deXf ghi
	//  */
	// };

	// class A {
	// /*  
	//  * abcd de
	//  * Xf ghi
	//  */
	// };
	public void testInsertNewLine10() {
		assertNewLineBehaviour();
	}

	// class A {
	// /* 
	//  * 
	//  */X
	// };

	// class A {
	// /* 
	//  * 
	//  */
	// X
	// };
	public void _testInsertNewLine11() { // this is correct - we're not in a dccaes partition
		assertNewLineBehaviour();
	}

	// /*X*/	

	// /*
	//  * X 
	//  */
	public void _testInsertNewLine12() {
		assertNewLineBehaviour();
	}

	// class A {
	// /*Xfoo
	// };  

	// class A {
	// /*
	//  * X
	//  */foo
	// };  
	public void testInsertNewLine13() {
		assertNewLineBehaviour();
	}

	// class A {
	// /*fooX
	// };  

	// class A {
	// /*foo
	//  * X
	//  */
	// };  
	public void testInsertNewLine14() {
		assertNewLineBehaviour();
	}


	// /*
	//  *
	//  *X

	// /*
	//  *
	//  *
	//  *X
	public void testInsertNewLine15() {
		assertNewLineBehaviour();
	}

	// /*
	//  *
	//  *Xxx

	// /*
	//  *
	//  *
	//  *Xxx
	public void testInsertNewLine16() {
		assertNewLineBehaviour();
	}

	// /*
	//   X

	// /*
	//   
	//   X
	public void testInsertNewLine17() {
		assertNewLineBehaviour();
	}

	// /*
	//   X
	//  */

	// /*
	//   
	//   X
	//  */
	public void testInsertNewLine18() {
		assertNewLineBehaviour();
	}

	//        /*
	//         *
	//         */   /*X

	//        /*
	//         *
	//         */   /*
	//               * X
	//               */
	public void _testInsertNewLine19() {
		assertNewLineBehaviour();
	}
	
	//        /*
	//        /*X
	//         *
	//         */

	//        /*
	//        /*
	//         * X
	//         *
	//         */
	public void testInsertNewLine20() {
		assertNewLineBehaviour();
	}


	//
	//  X
	//
	//  void foo() {}
	public void testFollowingDeclaration1() {
		assertDeclarationFollowingX("void foo() {}");
	}
	
	//  X
	//
	//  void foo() {}
	//  void bar() {}
	public void testFollowingDeclaration1b() {
		assertDeclarationFollowingX("void foo() {}");
	}


	//
	//  X
	//  class C {
	//  void foo() {}
	//  };
	public void testFollowingDeclaration2() {
		assertDeclarationFollowingX("class C {\n  void foo() {}\n  };");
	}

	//  class C {
	//  X
	//  void foo() {}
	//  };
	public void testFollowingDeclaration3() {
		assertDeclarationFollowingX("void foo() {}");
	}
	
	//  class C {
	//  void foo() {X}
	//  void bar(int x);
	//  };
	public void testFollowingDeclaration4() {
		assertDeclarationFollowingX(null);
	}

	//  class C {
	//  void foo() {} X
	//  void bar(int x);
	//  };
	public void testFollowingDeclaration4a() {
		assertDeclarationFollowingX("void bar(int x);");
	}
	
	//  class C {
	//  void foo()X{}
	//  void bar(int x);
	//  };
	public void _testFollowingDeclaration4b() { // XXX - this is likely invalid anyhow
		assertDeclarationFollowingX("void foo(){}"); // (X is just the cursor position)
	}
	
	//  class C {
	//  void foo()
	//  X
	//  {
	//     int x;
	//  }
	//  void bar(int x);
	//  };
	public void _testFollowingDeclaration4c() { // XXX - this is likely invalid anyhow
		assertDeclarationFollowingX("void foo()\n  {\n     int x;\n  }\n"); // (X is just the cursor position)
	}
	
	//  namespace n1 { X
	//		namespace n2 {
	//  		void foo() {}
	//  		void bar(int x) {}
	//          class C {
	//              int y;
	//              void baz(int x) {}
	//          };
	//		}
	//  }
	public void _testFollowingDeclaration5() {
		assertDeclarationFollowingX("namespace n2 {\n  		void foo() {}\n  		void bar(int x) {}\n          class C {\n              int y;\n              void baz(int x) {}\n          };\n		}");
	}
	
	//  namespace n1 {
	//		namespace n2 {X
	//  		void foo() {}
	//  		void bar(int x) {}
	//          class C {
	//              int y;
	//              void baz(int x) {}
	//          };
	//		}
	//  }
	public void testFollowingDeclaration6() {
		assertDeclarationFollowingX("void foo() {}");
	}
	
	//  namespace n1 {
	//		namespace n2 {
	//  		void foo() {}X
	//  		void bar(int x) {}
	//          class C {
	//              int y;
	//              void baz(int x) {}
	//          };
	//		}
	//  }
	public void testFollowingDeclaration7() {
		assertDeclarationFollowingX("void bar(int x) {}");
	}
	
	//  namespace n1 {
	//		namespace n2 {
	//  		void foo() {}
	//  		void bar(int x) {}
	//          class C {X
	//              int y;
	//              void baz(int x) {}
	//          };
	//		}
	//  }
	public void testFollowingDeclaration8() {
		assertDeclarationFollowingX("int y;");
	}
	
	//  namespace n1 {
	//		namespace n2 {
	//  		void foo() {}
	//  		void bar(int x) {}
	//          class C {
	//              int y;X
	//              void baz(int x) {}
	//          };
	//		}
	//  }
	public void testFollowingDeclaration9() {
		assertDeclarationFollowingX("void baz(int x) {}");
	}

	//  #define MM void foo()
	//  X
	//  MM {}
	public void testFollowingDeclaration10() {
		assertDeclarationFollowingX("MM {}");
	}
	
	//  #define NAME foo
	//  #define MM(V) void V(int y)
	//  X
	//  MM(NAME) {}
	public void testFollowingDeclaration11() {
		assertDeclarationFollowingX("MM(NAME) {}");
	}
	
	//  #define MAKEFUNC(V) void V()
	//  #define B(V) V
	//  #define C(V) foo ## x
	//  X
	//  MAKEFUNC(B(C(y))) {}
	public void testFollowingDeclaration12() {
		assertDeclarationFollowingX("MAKEFUNC(B(C(y))) {}");
	}
	
	/**
	 * @param rs - the raw signature of the declaration that should be returned
	 * or <code>null</code> if no declaration should be returned.
	 */
	protected void assertDeclarationFollowingX(String rs) {
		try {
			ICProject cproject= CProjectHelper.createCCProject("test"+System.currentTimeMillis(), "bin");
			try {
				String init= getTestContents1()[0].toString(); 
				int caretInit= init.indexOf('X');
				init= init.replaceFirst("X", "");
				IFile file= TestSourceReader.createFile(cproject.getProject(), "this.cpp", init);
				IASTTranslationUnit ast= TestSourceReader.createIndexBasedAST(null, cproject, file);
				assertNotNull(ast);
				IASTDeclaration decl= DefaultMultilineCommentAutoEditStrategy.findFollowingDeclaration(ast, caretInit);
				if(rs!=null) {
					assertNotNull(decl);
					assertEquals(rs, decl.getRawSignature());
				} else {
					assertNull(decl);
				}
			} finally {
				if(cproject!=null) {
					cproject.getProject().delete(true, NPM);
				}
			}
		} catch(CoreException ce) {
			fail(ce.getMessage());
		}
	}

	protected void assertNewLineBehaviour() {
		DefaultMultilineCommentAutoEditStrategy ds= new DefaultMultilineCommentAutoEditStrategy();
		CTextTools textTools = CUIPlugin.getDefault().getTextTools();
		IDocument doc = new Document();
		textTools.setupCDocument(doc);

		StringBuffer[] raw= getTestContents();
		String init= raw[0].toString(), expected= raw[1].toString();

		int caretInit= init.indexOf('X');
		init= init.replaceFirst("X", "");

		int caretExpected= expected.indexOf('X');
		expected= expected.replaceFirst("X", "");

		doc.set(init);
		int caretActual= -1;
		try {
			TestDocumentCommand dc= new TestDocumentCommand(caretInit, 0, "\n");
			ds.customizeDocumentCommand(doc, dc);
			caretActual= dc.exec(doc);
		} catch(BadLocationException ble) {
			fail(ble.getMessage());
		}
		String actual= doc.get();
		assertEquals(expected, actual);
		assertEquals(caretExpected, caretActual);
	}

	protected StringBuffer[] getTestContents() {
		try {
			return TestSourceReader.getContentsForTest(CTestPlugin.getDefault().getBundle(), "ui", this.getClass(), getName(), 2);
		} catch(IOException ioe) {
			fail(ioe.getMessage());
		}
		return null;
	}
	
	protected StringBuffer[] getTestContents1() {
		try {
			return TestSourceReader.getContentsForTest(CTestPlugin.getDefault().getBundle(), "ui", this.getClass(), getName(), 1);
		} catch(IOException ioe) {
			fail(ioe.getMessage());
		}
		return null;
	}
}




// N.B: Character positions in this file are hard-coded into expected results in
// DocCommentHightlightTest.

/* normal0 */
/*A comment1___ */
/*B comment2__ */
/*C comment3_ *//*D comment4___ */
/*E comment5____ *//*F comment6_ */
/*G comment7 
*//*F comment8_ *//*! __comment9 */
/**
comment10
*/

// snormal0
//A scomment1__
//B scomment2_
//C scomment3__
//! _scomment4
//* scomment5___

/*# comment11_ #*/ // scomment6__
/*# comment12__ #*/ //# __scomment7





/*******************************************************************************
 * Copyright (c) 2006, 2007 Wind River Systems, Inc. and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Anton Leherbauer (Wind River Systems) - initial API and implementation
 *     Sergey Prigogin, Google
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.ui.tests.text;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DocumentCommand;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.TextUtilities;

import org.eclipse.cdt.core.testplugin.util.BaseTestCase;

/**
 * IAutoEditStrategy related tests
 */
public class AbstractAutoEditTest extends BaseTestCase {
	
	AbstractAutoEditTest(String name) {
		super(name);
	}
	
	/**
	 * Helper class to test the auto-edit strategies on a document.
	 * Split out from CAutoIndentTest.
	 */
	static class AutoEditTester {

		private Map fStrategyMap = new HashMap();
		IDocument fDoc;
		private String fPartitioning;
		private int fCaretOffset;

		public AutoEditTester(IDocument doc, String partitioning) {
			super();
			fDoc = doc;
			fPartitioning = partitioning;
		}

		public void setAutoEditStrategy(String contentType, IAutoEditStrategy aes) {
			fStrategyMap.put(contentType, aes);
		}

		public IAutoEditStrategy getAutoEditStrategy(String contentType) {
			return (IAutoEditStrategy)fStrategyMap.get(contentType);
		}

		/**
		 * Empties the document, and returns the caret to the origin (0,0)
		 * @return <code>this</code> for method chaining
		 */
		public AutoEditTester reset() {
			try {
				goTo(0,0);
				fDoc.set("");
			} catch(BadLocationException ble) {
				fail(ble.getMessage());
			}
			return this;
		}
		
		public void type(String text) throws BadLocationException {
			for (int i = 0; i < text.length(); ++i) {
				type(text.charAt(i));
			}
		}

		public void type(char c) throws BadLocationException {
			TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, new String(new char[] { c }));
			customizeDocumentCommand(command);
			fCaretOffset = command.exec(fDoc);
		}

		private void customizeDocumentCommand(TestDocumentCommand command) throws BadLocationException {
			IAutoEditStrategy aes = getAutoEditStrategy(getContentType(command.offset));
			if (aes != null) {
				aes.customizeDocumentCommand(fDoc, command);
			}
		}

		public void type(int offset, String text) throws BadLocationException {
			fCaretOffset = offset;
			type(text);
		}

		public void type(int offset, char c) throws BadLocationException {
			fCaretOffset = offset;
			type(c);
		}

		public void paste(String text) throws BadLocationException {
			TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, text);
			customizeDocumentCommand(command);
			fCaretOffset = command.exec(fDoc);
		}

		public void paste(int offset, String text) throws BadLocationException {
			fCaretOffset = offset;
			paste(text);
		}

		public void backspace(int n) throws BadLocationException {
			for (int i = 0; i < n; ++i) {
				backspace();
			}
		}
		
		public void backspace() throws BadLocationException {
			TestDocumentCommand command = new TestDocumentCommand(fCaretOffset - 1, 1, ""); //$NON-NLS-1$
			customizeDocumentCommand(command);
			fCaretOffset = command.exec(fDoc);
		}

		public int getCaretOffset() {
			return fCaretOffset;
		}

		public int setCaretOffset(int offset) {
			fCaretOffset = offset;
			if (fCaretOffset < 0)
				fCaretOffset = 0;
			else if (fCaretOffset > fDoc.getLength())
				fCaretOffset = fDoc.getLength();
			return fCaretOffset;
		}
		
		/**
		 * Moves caret right or left by the given number of characters.
		 * 
		 * @param shift Move distance.
		 * @return New caret offset.
		 */
		public int moveCaret(int shift) {
			return setCaretOffset(fCaretOffset + shift);
		}
		
		public int goTo(int line) throws BadLocationException {
			fCaretOffset = fDoc.getLineOffset(line);
			return fCaretOffset;
		}

		public int goTo(int line, int column) throws BadLocationException {
			if (column < 0 || column > fDoc.getLineLength(line)) {
				throw new BadLocationException("No column " + column + " in line " + line); //$NON-NLS-1$ $NON-NLS-2$
			}
			fCaretOffset = fDoc.getLineOffset(line) + column;
			return fCaretOffset;
		}

		public int getCaretLine() throws BadLocationException {
			return fDoc.getLineOfOffset(fCaretOffset);
		}

		public int getCaretColumn() throws BadLocationException {
			IRegion region = fDoc.getLineInformationOfOffset(fCaretOffset);
			return fCaretOffset - region.getOffset();
		}

		public char getChar() throws BadLocationException {
			return getChar(0);
		}
		
		public char getChar(int i) throws BadLocationException {
			return fDoc.getChar(fCaretOffset+i);
		}
		
		public String getLine() throws BadLocationException {
			return getLine(0);
		}

		public String getLine(int i) throws BadLocationException {
			IRegion region = fDoc.getLineInformation(getCaretLine() + i);
			return fDoc.get(region.getOffset(), region.getLength());
		}

		public String getContentType(int offset) throws BadLocationException {
			return TextUtilities.getContentType(fDoc, fPartitioning, offset, true);
		}
	}
	
	/**
	 * A DocumentCommand with public constructor and exec method.
	 */
	static class TestDocumentCommand extends DocumentCommand {

		public TestDocumentCommand(int offset, int length, String text) {
			super();
			doit = true;
			this.text = text;

			this.offset = offset;
			this.length = length;

			owner = null;
			caretOffset = -1;
		}

		/**
		 * @param doc
		 * @return the new caret position.
		 * @throws BadLocationException
		 */
		public int exec(IDocument doc) throws BadLocationException {
			doc.replace(offset, length, text);
			return caretOffset != -1 ?
						caretOffset :
						offset + (text == null ? 0 : text.length());
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Symbian Software Systems and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 *******************************************************************************/
package org.eclipse.cdt.ui.tests.text.doctools;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.testplugin.CProjectHelper;
import org.eclipse.cdt.core.testplugin.util.BaseTestCase;
import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;

import org.eclipse.cdt.internal.ui.text.doctools.DocCommentOwnerManager;
import org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentOwner;

/**
 * Test comment ownership mapping
 */
public class CommentOwnerManagerTests extends BaseTestCase {
	IDocCommentOwner OWNER_1;
	IDocCommentOwner OWNER_2;
	IDocCommentOwner OWNER_3;
	DocCommentOwnerManager manager;
	
	ICProject projectA, projectB, projectC;
	
	protected void setUp() throws Exception {
		manager= DocCommentOwnerManager.getInstance();
		
		projectA= CProjectHelper.createCCProject("projectA", null);
		projectB= CProjectHelper.createCCProject("projectB", null);
		projectC= CProjectHelper.createCCProject("projectC", null);
		
		IDocCommentOwner[] owners= manager.getRegisteredOwners();
		OWNER_1= manager.getOwner("org.cdt.test.DCOM1");
		OWNER_2= manager.getOwner("org.cdt.test.DCOM2");
		OWNER_3= manager.getOwner("org.cdt.test.DCOM3");
	}
	
	protected void tearDown() throws Exception {
		if(projectA != null) {
			CProjectHelper.delete(projectA);
		}
		if(projectB != null) {
			CProjectHelper.delete(projectB);
		}
		if(projectC != null) {
			CProjectHelper.delete(projectC);			
		}
	}
	
	public static Test suite() {
		return new TestSuite(CommentOwnerManagerTests.class);
	}
	
	public void testProjectLevel() throws Exception {
		manager.setCommentOwner(projectA.getProject(), OWNER_3, true);
		manager.setCommentOwner(projectB.getProject(), OWNER_2, true);
		manager.setCommentOwner(projectC.getProject(), OWNER_1, true);
		
		assertEquals(OWNER_3.getID(), manager.getCommentOwner(projectA.getProject()).getID());
		assertEquals(OWNER_3.getID(), manager.getCommentOwner(projectA.getProject().getFile("foo/bar/baz")).getID());
		assertEquals(OWNER_3.getID(), manager.getCommentOwner(projectA.getProject().getFolder("foo/bar")).getID());
		
		assertEquals(OWNER_2.getID(), manager.getCommentOwner(projectB.getProject()).getID());
		assertEquals(OWNER_2.getID(), manager.getCommentOwner(projectB.getProject().getFile("foo/bar/baz")).getID());
		assertEquals(OWNER_2.getID(), manager.getCommentOwner(projectB.getProject().getFolder("foo/bar")).getID());

		assertEquals(OWNER_1.getID(), manager.getCommentOwner(projectC.getProject()).getID());
		assertEquals(OWNER_1.getID(), manager.getCommentOwner(projectC.getProject().getFile("foo/bar/baz")).getID());
		assertEquals(OWNER_1.getID(), manager.getCommentOwner(projectC.getProject().getFolder("foo/bar")).getID());
		
		manager.setCommentOwner(projectA.getProject(), OWNER_2, true);
		manager.setCommentOwner(projectB.getProject(), OWNER_1, true);
		manager.setCommentOwner(projectC.getProject(), OWNER_3, true);
		
		assertEquals(OWNER_2.getID(), manager.getCommentOwner(projectA.getProject()).getID());
		assertEquals(OWNER_2.getID(), manager.getCommentOwner(projectA.getProject().getFile("foo/bar/baz")).getID());
		assertEquals(OWNER_2.getID(), manager.getCommentOwner(projectA.getProject().getFolder("foo/bar")).getID());
		
		assertEquals(OWNER_1.getID(), manager.getCommentOwner(projectB.getProject()).getID());
		assertEquals(OWNER_1.getID(), manager.getCommentOwner(projectB.getProject().getFile("foo/bar/baz")).getID());
		assertEquals(OWNER_1.getID(), manager.getCommentOwner(projectB.getProject().getFolder("foo/bar")).getID());

		assertEquals(OWNER_3.getID(), manager.getCommentOwner(projectC.getProject()).getID());
		assertEquals(OWNER_3.getID(), manager.getCommentOwner(projectC.getProject().getFile("foo/bar/baz")).getID());
		assertEquals(OWNER_3.getID(), manager.getCommentOwner(projectC.getProject().getFolder("foo/bar")).getID());
		
		projectA.getProject().close(NPM);
		projectB.getProject().close(NPM);
		projectC.getProject().close(NPM);
		
		projectA.getProject().open(NPM);
		projectB.getProject().open(NPM);
		projectC.getProject().open(NPM);
		
		assertEquals(OWNER_2.getID(), manager.getCommentOwner(projectA.getProject()).getID());
		assertEquals(OWNER_2.getID(), manager.getCommentOwner(projectA.getProject().getFile("foo/bar/baz")).getID());
		assertEquals(OWNER_2.getID(), manager.getCommentOwner(projectA.getProject().getFolder("foo/bar")).getID());
		
		assertEquals(OWNER_1.getID(), manager.getCommentOwner(projectB.getProject()).getID());
		assertEquals(OWNER_1.getID(), manager.getCommentOwner(projectB.getProject().getFile("foo/bar/baz")).getID());
		assertEquals(OWNER_1.getID(), manager.getCommentOwner(projectB.getProject().getFolder("foo/bar")).getID());

		assertEquals(OWNER_3.getID(), manager.getCommentOwner(projectC.getProject()).getID());
		assertEquals(OWNER_3.getID(), manager.getCommentOwner(projectC.getProject().getFile("foo/bar/baz")).getID());
		assertEquals(OWNER_3.getID(), manager.getCommentOwner(projectC.getProject().getFolder("foo/bar")).getID());
	}
	
	public void testBoundaryConditions() throws Exception {
		DocCommentOwnerManager manager= DocCommentOwnerManager.getInstance();
		assertEquals(NullDocCommentOwner.INSTANCE.getID(), manager.getCommentOwner(null).getID());
	}
	
	public void testWorkspaceRootLevel() throws Exception {
		// TODO
	}
}

Return to bug 208881

Added Link Here

(-)src/org/eclipse/core/filebuffers/tests/ResourceTextFileManagerDocCreationTests.java (+35 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Symbian Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Andrew Ferguson (Symbian) - Initial implementation
10	*******************************************************************************/
11	package org.eclipse.core.filebuffers.tests;
12
13	import org.eclipse.core.filebuffers.LocationKind;
14	import org.eclipse.core.internal.filebuffers.ResourceTextFileBufferManager;
15	import org.eclipse.core.resources.IFile;
16	import org.eclipse.core.resources.ResourcesPlugin;
17	import org.eclipse.core.runtime.Path;
18
19	public class ResourceTextFileManagerDocCreationTests extends AbstractFileBufferDocCreationTests {
20	protected void setUp() throws Exception {
21	fManager= new ResourceTextFileBufferManager();
22	}
23
24	protected void assertDocumentContent(String expectedContent, String fullPath, LocationKind locKind) {
25	assertEquals(expectedContent, fManager.createEmptyDocument(new Path(fullPath), locKind).get());
26	if(locKind.equals(LocationKind.IFILE)) {
27	IFile file= ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(fullPath));
28	assertEquals(expectedContent, ((ResourceTextFileBufferManager)fManager).createEmptyDocument(file).get());
29	}
30	}
31
32	protected LocationKind[] getSupportLocationKinds() {
33	return new LocationKind[] {LocationKind.IFILE, LocationKind.LOCATION, LocationKind.NORMALIZE};
34	}
35	}

Added Link Here

(-)plugin.xml (+75 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<?eclipse version="3.2"?>
3	<!--
4	-
5	- Register IDocumentSetupParticipants against names and extensions that won't interfere with
6	- normal operation.
7	-
8	-->
9	<plugin>
10	<!-- IDocumentSetupParticipant -->
11	<extension point="org.eclipse.core.filebuffers.documentSetup">
12	<participant
13	class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP1"
14	extensions="111foo">
15	</participant>
16	</extension>
17	<extension point="org.eclipse.core.filebuffers.documentSetup">
18	<participant
19	class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP2"
20	fileNames="111fooname,111fooname.111foo">
21	</participant>
22	</extension>
23	<extension point="org.eclipse.core.filebuffers.documentSetup">
24	<participant
25	class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP3"
26	extensions="111foo"
27	fileNames="111fooname,111fooname.111foo">
28	</participant>
29	</extension>
30
31	<!-- IDocumentSetupParticipantExtension ignoring hint -->
32	<extension point="org.eclipse.core.filebuffers.documentSetup">
33	<participant
34	class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP4"
35	extensions="222foo">
36	</participant>
37	</extension>
38	<extension point="org.eclipse.core.filebuffers.documentSetup">
39	<participant
40	class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP5"
41	fileNames="222fooname,222fooname.222foo">
42	</participant>
43	</extension>
44	<extension point="org.eclipse.core.filebuffers.documentSetup">
45	<participant
46	class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP6"
47	extensions="222foo"
48	fileNames="222fooname,222fooname.222foo">
49	</participant>
50	</extension>
51
52	<!-- IDocumentSetupPartcipantExtension selectively picking up hint -->
53	<extension point="org.eclipse.core.filebuffers.documentSetup">
54	<participant
55	class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP7"
56	extensions="333foo"
57	fileNames="333fooname,333fooname.333foo">
58	</participant>
59	</extension>
60	<extension point="org.eclipse.core.filebuffers.documentSetup">
61	<participant
62	class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP8"
63	extensions="444foo"
64	fileNames="444fooname,444fooname.444foo">
65	</participant>
66	</extension>
67	<extension point="org.eclipse.core.filebuffers.documentSetup">
68	<participant
69	class="org.eclipse.core.filebuffers.tests.MockDocumentSetupParticipants$TestDSP9"
70	extensions="555foo"
71	fileNames="555fooname,555fooname.555foo">
72	</participant>
73	</extension>
74	</plugin>
75

Lines 44-50 Link Here

(-)src/org/eclipse/cdt/internal/ui/text/CAutoIndentStrategy.java (-32 / +8 lines)
44	* Auto indent strategy sensitive to brackets.	44	* Auto indent strategy sensitive to brackets.
45	*/	45	*/
46	public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {	46	public class CAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
47	private static final String MULTILINE_COMMENT_CLOSE = "*/"; //$NON-NLS-1$
48	/** The line comment introducer. Value is "{@value}" */	47	/** The line comment introducer. Value is "{@value}" */
49	private static final String LINE_COMMENT= "//"; //$NON-NLS-1$	48	private static final String LINE_COMMENT= "//"; //$NON-NLS-1$
50	// private static final GCCScannerExtensionConfiguration C_GNU_SCANNER_EXTENSION = new GCCScannerExtensionConfiguration();	49	// private static final GCCScannerExtensionConfiguration C_GNU_SCANNER_EXTENSION = new GCCScannerExtensionConfiguration();
Lines 1120-1162 Link Here
1120	super.customizeDocumentCommand(d, c);	1119	super.customizeDocumentCommand(d, c);
1121	return;	1120	return;
1122	}	1121	}
1123		1122
1124	if (c.length == 0 && c.text != null && isLineDelimiter(d, c.text)) {	1123	/*
1125	if (isAppendToOpenMultilineComment(d, c)) {	1124	* I removed the workaround for 48339 as I believe the recent changes to
1126	// special case: multi-line comment at end of document (bug 48339)	1125	* FastCPartitioner are enough to fix this.
1127	CCommentAutoIndentStrategy.commentIndentAfterNewLine(d, c);	1126	*/
1128	} else {	1127	boolean isNewLine= c.length == 0 && c.text != null && isLineDelimiter(d, c.text);
1129	smartIndentAfterNewLine(d, c);	1128	if (isNewLine) {
1130	}	1129	smartIndentAfterNewLine(d, c);
1131	} else if ("/".equals(c.text) && isAppendToOpenMultilineComment(d, c)) { //$NON-NLS-1$
1132	// special case: multi-line comment at end of document (bug 48339)
1133	CCommentAutoIndentStrategy.commentIndentForCommentEnd(d, c);
1134	} else if (c.text.length() == 1) {	1130	} else if (c.text.length() == 1) {
1135	smartIndentOnKeypress(d, c);	1131	smartIndentOnKeypress(d, c);
1136	} else if (c.text.length() > 1 && getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_PASTE)) {	1132	} else if (c.text.length() > 1 && getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_PASTE)) {
1137	smartPaste(d, c); // no smart backspace for paste	1133	smartPaste(d, c); // no smart backspace for paste
1138	}	1134	}
1139	}	1135	}
1140
1141	/**
1142	* Check, if the command appends to an open multi-line comment.
1143	* @param d the document
1144	* @param c the document command
1145	* @return true, if the command appends to an open multi-line comment.
1146	*/
1147	private boolean isAppendToOpenMultilineComment(IDocument d, DocumentCommand c) {
1148	if (d.getLength() >= 2 && c.offset == d.getLength()) {
1149	try {
1150	String contentType = TextUtilities.getContentType(d, fPartitioning, c.offset - 1, false);
1151	if (ICPartitions.C_MULTI_LINE_COMMENT.equals(contentType)) {
1152	return !d.get(c.offset - 2, 2).equals(MULTILINE_COMMENT_CLOSE);
1153	}
1154	} catch (BadLocationException exc) {
1155	// see below
1156	}
1157	}
1158	return false;
1159	}
1160		1136
1161	private static IPreferenceStore getPreferenceStore() {	1137	private static IPreferenceStore getPreferenceStore() {
1162	return CUIPlugin.getDefault().getCombinedPreferenceStore();	1138	return CUIPlugin.getDefault().getCombinedPreferenceStore();

Lines 88-93 Link Here

(-)src/org/eclipse/cdt/ui/CUIPlugin.java (+6 lines)
88	import org.eclipse.cdt.internal.ui.text.CTextTools;	88	import org.eclipse.cdt.internal.ui.text.CTextTools;
89	import org.eclipse.cdt.internal.ui.text.PreferencesAdapter;	89	import org.eclipse.cdt.internal.ui.text.PreferencesAdapter;
90	import org.eclipse.cdt.internal.ui.text.c.hover.CEditorTextHoverDescriptor;	90	import org.eclipse.cdt.internal.ui.text.c.hover.CEditorTextHoverDescriptor;
		91	import org.eclipse.cdt.internal.ui.text.doctools.DocCommentOwnerManager;
		92	import org.eclipse.cdt.internal.ui.text.doctools.EditorReopener;
91	import org.eclipse.cdt.internal.ui.text.folding.CFoldingStructureProviderRegistry;	93	import org.eclipse.cdt.internal.ui.text.folding.CFoldingStructureProviderRegistry;
92	import org.eclipse.cdt.internal.ui.util.ImageDescriptorRegistry;	94	import org.eclipse.cdt.internal.ui.util.ImageDescriptorRegistry;
93	import org.eclipse.cdt.internal.ui.util.ProblemMarkerManager;	95	import org.eclipse.cdt.internal.ui.util.ProblemMarkerManager;
Lines 102-107 Link Here
102	public static final String CVIEW_ID = PLUGIN_ID + ".CView"; //$NON-NLS-1$	104	public static final String CVIEW_ID = PLUGIN_ID + ".CView"; //$NON-NLS-1$
103	public static final String C_PROBLEMMARKER = PLUGIN_CORE_ID + ".problem"; //$NON-NLS-1$	105	public static final String C_PROBLEMMARKER = PLUGIN_CORE_ID + ".problem"; //$NON-NLS-1$
104		106
		107	public static final String ID_COMMENT_OWNER= PLUGIN_ID+".DocCommentOwner"; //$NON-NLS-1$
		108
105	public static final String ID_INCLUDE_BROWSER= PLUGIN_ID + ".includeBrowser"; //$NON-NLS-1$	109	public static final String ID_INCLUDE_BROWSER= PLUGIN_ID + ".includeBrowser"; //$NON-NLS-1$
106	public static final String ID_CALL_HIERARCHY= PLUGIN_ID + ".callHierarchy"; //$NON-NLS-1$	110	public static final String ID_CALL_HIERARCHY= PLUGIN_ID + ".callHierarchy"; //$NON-NLS-1$
107	public static final String ID_TYPE_HIERARCHY = PLUGIN_ID + ".typeHierarchy"; //$NON-NLS-1$	111	public static final String ID_TYPE_HIERARCHY = PLUGIN_ID + ".typeHierarchy"; //$NON-NLS-1$
Lines 475-480 Link Here
475	getASTProvider();	479	getASTProvider();
476	CDTContextActivator.getInstance().install();	480	CDTContextActivator.getInstance().install();
477		481
		482	DocCommentOwnerManager.getInstance().addListener(new EditorReopener());
		483
478	// start make-ui plugin, such that it can check for project conversions.	484	// start make-ui plugin, such that it can check for project conversions.
479	Job job= new Job(Messages.CUIPlugin_jobStartMakeUI) {	485	Job job= new Job(Messages.CUIPlugin_jobStartMakeUI) {
480	protected IStatus run(IProgressMonitor monitor) {	486	protected IStatus run(IProgressMonitor monitor) {

Lines 23-29 Link Here

(-)src/org/eclipse/cdt/ui/text/ICPartitions.java (-1 / +25 lines)
23	String C_PARTITIONING= "___c_partitioning"; //$NON-NLS-1$	23	String C_PARTITIONING= "___c_partitioning"; //$NON-NLS-1$
24		24
25	/**	25	/**
26	* The identifier of the single-line end comment partition content type.	26	* The identifier of the single-line comment partition content type.
27	*/	27	*/
28	String C_SINGLE_LINE_COMMENT= "__c_singleline_comment"; //$NON-NLS-1$	28	String C_SINGLE_LINE_COMMENT= "__c_singleline_comment"; //$NON-NLS-1$
29		29
Lines 46-49 Link Here
46	* The identifier of the C preprocessor partition content type.	46	* The identifier of the C preprocessor partition content type.
47	*/	47	*/
48	String C_PREPROCESSOR= "__c_preprocessor"; //$NON-NLS-1$	48	String C_PREPROCESSOR= "__c_preprocessor"; //$NON-NLS-1$
		49
		50	/**
		51	* The identifier of the single-line documentation tool comment partition content type.
		52	*/
		53	String C_SINGLE_LINE_DOC_COMMENT= "__c_singleline_doc_comment"; //$NON-NLS-1$
		54
		55	/**
		56	* The identifier multi-line comment documentation tool partition content type.
		57	*/
		58	String C_MULTI_LINE_DOC_COMMENT= "__c_multiline_doc_comment"; //$NON-NLS-1$
		59
		60	/**
		61	*
		62	* @since 5.0
		63	*/
		64	String[] ALL_CPARTITIONS= {
		65	ICPartitions.C_MULTI_LINE_COMMENT,
		66	ICPartitions.C_SINGLE_LINE_COMMENT,
		67	ICPartitions.C_STRING,
		68	ICPartitions.C_CHARACTER,
		69	ICPartitions.C_PREPROCESSOR,
		70	ICPartitions.C_SINGLE_LINE_DOC_COMMENT,
		71	ICPartitions.C_MULTI_LINE_DOC_COMMENT
		72	};
49	}	73	}

Added Link Here

(-)src/org/eclipse/cdt/ui/text/doctools/generic/GenericTagCompletionProposalComputer.java (+104 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Symbian Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Andrew Ferguson (Symbian) - Initial implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.ui.text.doctools.generic;
12
13	import java.util.ArrayList;
14	import java.util.Collections;
15	import java.util.List;
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.ITypedRegion;
21	import org.eclipse.jface.text.TextUtilities;
22
23	import org.eclipse.cdt.ui.text.ICPartitions;
24	import org.eclipse.cdt.ui.text.contentassist.ContentAssistInvocationContext;
25	import org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer;
26
27	import org.eclipse.cdt.internal.ui.text.contentassist.CCompletionProposal;
28
29	/**
30	* CompletionProposalComputer based on a specified set of GenericTag objects.
31	*/
32	public class GenericTagCompletionProposalComputer implements ICompletionProposalComputer {
33	char[] tagMarkers;
34
35	GenericDocTag[] tags;
36
37	public GenericTagCompletionProposalComputer(GenericDocTag[] tags) {
38	this.tags= tags;
39	this.tagMarkers= new char[] {'@','\\'};
40	}
41
42	protected boolean isTagMarker(char c) {
43	for(int i=0; i<tagMarkers.length; i++)
44	if(c == tagMarkers[i])
45	return true;
46	return false;
47	}
48
49
50	public List computeCompletionProposals(ContentAssistInvocationContext context, IProgressMonitor monitor) {
51	IDocument doc= context.getDocument();
52	int ivcOffset= context.getInvocationOffset();
53	try {
54	ITypedRegion tr= TextUtilities.getPartition(doc, ICPartitions.C_PARTITIONING, ivcOffset, false);
55	int firstNonWS= ivcOffset;
56	while(firstNonWS-1> tr.getOffset() && !Character.isWhitespace(doc.get(firstNonWS-1, 1).charAt(0)))
57	firstNonWS--;
58	String prefix= doc.get(firstNonWS, ivcOffset-firstNonWS);
59	if(prefix.length()>0 && isTagMarker(prefix.charAt(0))) {
60	List proposals= new ArrayList();
61	char tagMarker= prefix.charAt(0);
62	for(int i=0; i<tags.length; i++) {
63	String tag= tags[i].getTagName();
64	if(tag.toLowerCase().startsWith(prefix.substring(1).toLowerCase())) {
65	CCompletionProposal proposal= new CCompletionProposal(tagMarker+tag, ivcOffset-prefix.length(), prefix.length(), null, tagMarker+tag, 1, context.getViewer());
66	String description= tags[i].getTagDescription();
67	if(description!=null && !description.equals("")) { //$NON-NLS-1$
68	proposal.setAdditionalProposalInfo(description);
69	}
70	proposals.add(proposal);
71	}
72	}
73	return proposals;
74	}
75	} catch(BadLocationException ble) {
76	// offset is zero, ignore
77	}
78	return new ArrayList();
79	}
80
81	/*
82	* @see org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer#computeContextInformation(org.eclipse.cdt.ui.text.contentassist.ContentAssistInvocationContext, org.eclipse.core.runtime.IProgressMonitor)
83	*/
84	public List computeContextInformation(ContentAssistInvocationContext context, IProgressMonitor monitor) {
85	return Collections.EMPTY_LIST;
86	}
87
88	/*
89	* @see org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer#getErrorMessage()
90	*/
91	public String getErrorMessage() {
92	return null;
93	}
94
95	/*
96	* @see org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer#sessionEnded()
97	*/
98	public void sessionEnded() {}
99
100	/*
101	* @see org.eclipse.cdt.ui.text.contentassist.ICompletionProposalComputer#sessionStarted()
102	*/
103	public void sessionStarted() {}
104	}

Added Link Here

(-)src/org/eclipse/cdt/ui/text/ICTokenScanner.java (+23 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Symbian Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Andrew Ferguson (Symbian) - Initial implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.ui.text;
12
13	import org.eclipse.jface.text.rules.ITokenScanner;
14	import org.eclipse.cdt.ui.IPropertyChangeParticipant;
15
16	/**
17	* Interface for CDT Scanners. Scanners used in CDT must additionally be
18	* IPropertyChangeParticipant's.
19	*
20	* @since 5.0
21	*/
22	public interface ICTokenScanner extends ITokenScanner, IPropertyChangeParticipant {
23	}

Added Link Here

(-)src/org/eclipse/cdt/ui/text/ITokenStoreFactory.java (+23 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Symbian Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Andrew Ferguson (Symbian) - Initial implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.ui.text;
12
13	/**
14	* A means of obtaining ITokenStore objects
15	* @since 5.0
16	*/
17	public interface ITokenStoreFactory {
18	/**
19	* @param propertyColorNames
20	* @return a token store object initialized with the specified propertyColorNames
21	*/
22	public ITokenStore createTokenStore(String[] propertyColorNames);
23	}

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/text/doctools/docpp/DocppMultilineAutoEditStrategy.java (+80 lines)
1	package org.eclipse.cdt.internal.ui.text.doctools.docpp;
2
3	import org.eclipse.jface.text.IAutoEditStrategy;
4	import org.eclipse.jface.text.IDocument;
5	import org.eclipse.jface.text.ITypedRegion;
6
7	import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier;
8	import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
9	import org.eclipse.cdt.core.dom.ast.IASTDeclarator;
10	import org.eclipse.cdt.core.dom.ast.IASTFunctionDeclarator;
11	import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition;
12	import org.eclipse.cdt.core.dom.ast.IASTParameterDeclaration;
13	import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclSpecifier;
14	import org.eclipse.cdt.core.dom.ast.IASTStandardFunctionDeclarator;
15	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateDeclaration;
16	import org.eclipse.cdt.ui.text.doctools.DefaultMultilineCommentAutoEditStrategy;
17
18	/**
19	* {@link IAutoEditStrategy} for adding Docpp tags for comments.
20	*/
21	public class DocppMultilineAutoEditStrategy extends DefaultMultilineCommentAutoEditStrategy {
22	private static final String PARAM = "@param "; //$NON-NLS-1$
23	private static final String RETURN = "@return\n"; //$NON-NLS-1$
24
25	protected StringBuffer paramTags(IASTParameterDeclaration[] decls) {
26	StringBuffer result= new StringBuffer();
27	for(int i=0; i<decls.length; i++) {
28	IASTDeclarator dtor= decls[i].getDeclarator();
29	result.append(PARAM+dtor.getName()+"\n"); //$NON-NLS-1$
30	}
31	return result;
32	}
33
34	protected StringBuffer returnTag() {
35	return new StringBuffer(RETURN);
36	}
37
38	protected IASTParameterDeclaration[] getParameterDecls(IASTFunctionDefinition def) {
39	IASTParameterDeclaration[] result;
40	IASTFunctionDeclarator decl= def.getDeclarator();
41	if (decl instanceof IASTStandardFunctionDeclarator) {
42	IASTStandardFunctionDeclarator standardFunctionDecl= (IASTStandardFunctionDeclarator)decl;
43	result= standardFunctionDecl.getParameters();
44	} else /*if (def instanceof ICASTKnRFunctionDeclarator) {
45	ICASTKnRFunctionDeclarator knrDeclarator= (ICASTKnRFunctionDeclarator)decl;
46	result= knrDeclarator.getParameterDeclarations();
47	} else */{
48	result= new IASTParameterDeclaration[0];
49	}
50	return result;
51	}
52
53	public StringBuffer customizeAfterNewLineForDeclaration(IDocument doc, IASTDeclaration dec, ITypedRegion partition) {
54	StringBuffer result= new StringBuffer();
55
56	while(dec instanceof ICPPASTTemplateDeclaration) /* if? */
57	dec= ((ICPPASTTemplateDeclaration)dec).getDeclaration();
58
59	if(dec instanceof IASTFunctionDefinition) {
60	IASTFunctionDefinition fd= (IASTFunctionDefinition) dec;
61	result.append(paramTags(getParameterDecls(fd)));
62
63	IASTDeclSpecifier ds= fd.getDeclSpecifier();
64	boolean hasReturn= true;
65	if(ds instanceof IASTSimpleDeclSpecifier) {
66	IASTSimpleDeclSpecifier sds= (IASTSimpleDeclSpecifier) ds;
67	if(sds.getType()==IASTSimpleDeclSpecifier.t_void) {
68	hasReturn= false;
69	}
70	}
71	if(hasReturn) {
72	result.append(returnTag());
73	}
74
75	return result;
76	}
77
78	return new StringBuffer();
79	}
80	}

Added Link Here

(-)src/org/eclipse/cdt/ui/IPropertyChangeParticipant.java (+35 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Symbian Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Andrew Ferguson (Symbian) - Initial Implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.ui;
12
13	import org.eclipse.jface.util.PropertyChangeEvent;
14
15	/**
16	* Implemented by classes which can optionally participate in property
17	* change events, and report whether an event would affect them without
18	* adapting to it.
19	*
20	* @since 5.0
21	*/
22	public interface IPropertyChangeParticipant {
23	/**
24	* @param event
25	* @return true if the specified event will affect the participant's
26	* behaviour in a way it determines potential clients could act upon.
27	*/
28	public boolean affectsBehavior(PropertyChangeEvent event);
29
30	/**
31	* Performs any necessary to adapt the participant to the specified event.
32	* @param event
33	*/
34	public void adaptToPreferenceChange(PropertyChangeEvent event);
35	}

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/text/doctools/doxygen/tags.csv (+116 lines)
1	a,,
2	addindex,,
3	addtogroup,,
4	anchor,,
5	arg,,
6	attention,,
7	author,,
8	b,,
9	brief,,
10	bug,,
11	c,,
12	callgraph,,
13	callergraph,,
14	category,,
15	class,,
16	code,,
17	cond,,
18	copydoc,,
19	date,,
20	def,,
21	defgroup,,
22	deprecated,,
23	details,,
24	dir,,
25	dontinclude,,
26	dot,,
27	dotfile,,
28	e,,
29	else,,
30	elseif,,
31	em,,
32	endcode,,
33	endcond,,
34	enddot,,
35	endhtmlonly,,
36	endif,,
37	endlatexonly,,
38	endlink,,
39	endmanonly,,
40	endmsc,,
41	endverbatim,,
42	endxmlonly,,
43	enum,,
44	example,,
45	exception,,
46	f$,,
47	f[,,
48	f],,
49	file,,
50	fn,,
51	hideinitializer,,
52	htmlinclude,,
53	htmlonly,,
54	if,,
55	ifnot,,
56	image,,
57	include,,
58	includelineno,,
59	ingroup,,
60	internal,,
61	invariant,,
62	interface,,
63	latexonly,,
64	li,,
65	line,,
66	link,,
67	mainpage,,
68	manonly,,
69	msc,,
70	n,,
71	name,,
72	namespace,,
73	nosubgrouping,,
74	note,,
75	overload,,
76	p,,
77	package,,
78	page,,
79	par,,
80	paragraph,,
81	param,,
82	post,,
83	pre,,
84	property,,
85	protocol,,
86	ref,,
87	relates,,
88	relatesalso,,
89	remarks,,
90	return,,
91	retval,,
92	sa,,
93	section,,
94	see,,
95	showinitializer,,
96	since,,
97	skip,,
98	skipline,,
99	struct,,
100	subpage,,
101	subsection,,
102	subsubsection,,
103	test,,
104	throw,,
105	todo,,
106	typedef,,
107	union,,
108	until,,
109	var,,
110	verbatim,,
111	verbinclude,,
112	version,,
113	warning,,
114	weakgroup,,
115	xmlonly,,
116	xrefitem,,

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/text/TokenStore.java (+275 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	* QNX Software System
11	* Andrew Ferguson (Symbian) - refactored to TokenStore (previously part of AbstractCScanner)
12	*******************************************************************************/
13	package org.eclipse.cdt.internal.ui.text;
14
15
16	import java.util.HashMap;
17	import java.util.Map;
18
19	import org.eclipse.jface.preference.IPreferenceStore;
20	import org.eclipse.jface.preference.PreferenceConverter;
21	import org.eclipse.jface.resource.StringConverter;
22	import org.eclipse.jface.text.TextAttribute;
23	import org.eclipse.jface.text.rules.IToken;
24	import org.eclipse.jface.text.rules.Token;
25	import org.eclipse.jface.util.PropertyChangeEvent;
26	import org.eclipse.swt.SWT;
27	import org.eclipse.swt.graphics.Color;
28	import org.eclipse.swt.graphics.RGB;
29	import org.eclipse.swt.widgets.Display;
30
31	import org.eclipse.cdt.ui.PreferenceConstants;
32	import org.eclipse.cdt.ui.text.ITokenStore;
33
34
35	/**
36	* Maintains a pool of tokens identified by a String ID.
37	* Supports styles per token.
38	* Updates token instances on property changes.
39	*/
40
41	public class TokenStore implements ITokenStore {
42	private IColorManager fColorManager;
43	private IPreferenceStore fPreferenceStore;
44
45	private Map fTokenMap= new HashMap();
46	private String[] fPropertyNamesColor;
47
48	private boolean fNeedsLazyColorLoading;
49
50	/**
51	* Maintains tokens for a specified set of property keys. Automatically also
52	* copes with bold, italic, strikethrough and underlined versions of the key.
53	* @param manager the IColorManager to retrieve token colors from
54	* @param store the {@link IPreferenceStore} to fetch property preferences from
55	*/
56	public TokenStore(IColorManager manager, IPreferenceStore store, String[] propertyNamesColor) {
57	fColorManager= manager;
58	fPreferenceStore= store;
59
60	fPropertyNamesColor= propertyNamesColor;
61
62	fNeedsLazyColorLoading= Display.getCurrent() == null;
63	for (int i= 0; i < fPropertyNamesColor.length; i++) {
64	if(fPropertyNamesColor[i].endsWith(PreferenceConstants.EDITOR_BOLD_SUFFIX)
65	\|\| fPropertyNamesColor[i].endsWith(PreferenceConstants.EDITOR_ITALIC_SUFFIX)
66	\|\| fPropertyNamesColor[i].endsWith(PreferenceConstants.EDITOR_STRIKETHROUGH_SUFFIX)
67	\|\| fPropertyNamesColor[i].endsWith(PreferenceConstants.EDITOR_UNDERLINE_SUFFIX)) {
68	throw new IllegalArgumentException(); // XXX
69	}
70	if (fNeedsLazyColorLoading)
71	addTokenWithProxyAttribute(fPropertyNamesColor[i]);
72	else
73	addToken(fPropertyNamesColor[i]);
74	}
75	}
76
77	/**
78	* In the case where at the time of IToken construction, the Display was not
79	* ready to construct colors.
80	*/
81	public void ensureTokensInitialised() {
82	if (fNeedsLazyColorLoading && Display.getCurrent() != null) {
83	for (int i= 0; i < fPropertyNamesColor.length; i++) {
84	addToken(fPropertyNamesColor[i]);
85	}
86	fNeedsLazyColorLoading= false;
87	}
88	}
89
90	private void addTokenWithProxyAttribute(String colorKey) {
91	fTokenMap.put(colorKey, new Token(createTextAttribute(colorKey, true)));
92	}
93
94	private void addToken(String colorKey) {
95	if (fColorManager != null && colorKey != null && fColorManager.getColor(colorKey) == null) {
96	RGB rgb= PreferenceConverter.getColor(fPreferenceStore, colorKey);
97	if (fColorManager instanceof IColorManagerExtension) {
98	IColorManagerExtension ext= (IColorManagerExtension) fColorManager;
99	ext.unbindColor(colorKey);
100	ext.bindColor(colorKey, rgb);
101	}
102	}
103
104	if (!fNeedsLazyColorLoading)
105	fTokenMap.put(colorKey, new Token(createTextAttribute(colorKey, false)));
106	else {
107	Token token= ((Token)fTokenMap.get(colorKey));
108	if (token != null)
109	token.setData(createTextAttribute(colorKey, false));
110	}
111	}
112
113	/**
114	* Create a text attribute based on the given color, bold, italic, strikethrough and underline preference keys.
115	*
116	* @param colorKey the color preference key
117	* @param boldKey the bold preference key
118	* @param italicKey the italic preference key
119	* @param strikethroughKey the strikethrough preference key
120	* @param underlineKey the italic preference key
121	* @return the created text attribute
122	* @since 3.0
123	*/
124	private TextAttribute createTextAttribute(String colorKey, boolean isNull) {
125	Color color= null;
126	if (!isNull)
127	color= fColorManager.getColor(colorKey);
128
129	String boldKey= colorKey + PreferenceConstants.EDITOR_BOLD_SUFFIX;
130	String italicKey= colorKey + PreferenceConstants.EDITOR_ITALIC_SUFFIX;
131	String strikethroughKey= colorKey + PreferenceConstants.EDITOR_STRIKETHROUGH_SUFFIX;
132	String underlineKey= colorKey + PreferenceConstants.EDITOR_UNDERLINE_SUFFIX;
133
134	int style= fPreferenceStore.getBoolean(boldKey) ? SWT.BOLD : SWT.NORMAL;
135	if (fPreferenceStore.getBoolean(italicKey))
136	style \|= SWT.ITALIC;
137
138	if (fPreferenceStore.getBoolean(strikethroughKey))
139	style \|= TextAttribute.STRIKETHROUGH;
140
141	if (fPreferenceStore.getBoolean(underlineKey))
142	style \|= TextAttribute.UNDERLINE;
143
144	return new TextAttribute(color, null, style);
145	}
146
147	/*
148	* (non-Javadoc)
149	* @see org.eclipse.cdt.ui.text.ITokenStore#getToken(java.lang.String)
150	*/
151	public IToken getToken(String key) {
152	return getTokenInner(key);
153	}
154
155	private Token getTokenInner(String key) {
156	ensureTokensInitialised();
157	return (Token) fTokenMap.get(key);
158	}
159
160	private int indexOf(String property) {
161	if (property != null) {
162	int length= fPropertyNamesColor.length;
163	for (int i= 0; i < length; i++) {
164	if (property.startsWith(fPropertyNamesColor[i])) {
165	int pLength= property.length();
166	if(fPropertyNamesColor[i].length() < pLength) {
167	String end= property.substring(fPropertyNamesColor[i].length());
168	if (end.equals(PreferenceConstants.EDITOR_BOLD_SUFFIX)
169	\|\| end.equals(PreferenceConstants.EDITOR_ITALIC_SUFFIX)
170	\|\| end.equals(PreferenceConstants.EDITOR_STRIKETHROUGH_SUFFIX)
171	\|\| end.equals(PreferenceConstants.EDITOR_UNDERLINE_SUFFIX)) {
172	return i;
173	}
174	} else if (fPropertyNamesColor[i].equals(property)) {
175	return i;
176	}
177	}
178	}
179	}
180	return -1;
181	}
182
183	/*
184	* (non-Javadoc)
185	* @see org.eclipse.cdt.ui.IPropertyChangeParticipant#affectsBehavior(org.eclipse.jface.util.PropertyChangeEvent)
186	*/
187	public boolean affectsBehavior(PropertyChangeEvent event) {
188	return indexOf(event.getProperty()) >= 0;
189	}
190
191	/*
192	* (non-Javadoc)
193	* @see org.eclipse.cdt.ui.IPropertyChangeParticipant#adaptToPreferenceChange(org.eclipse.jface.util.PropertyChangeEvent)
194	*/
195	public void adaptToPreferenceChange(PropertyChangeEvent event) {
196	String property= event.getProperty();
197	int i= indexOf(property);
198	if (property.startsWith(fPropertyNamesColor[i])) {
199	Token token= getTokenInner(fPropertyNamesColor[i]);
200	if(property.length() == fPropertyNamesColor[i].length()) {
201	adaptToColorChange(token, event);
202	} else {
203	String end= property.substring(fPropertyNamesColor[i].length());
204	if (end.equals(PreferenceConstants.EDITOR_BOLD_SUFFIX)) {
205	adaptToStyleChange(token, event, SWT.BOLD);
206	} else if (end.equals(PreferenceConstants.EDITOR_ITALIC_SUFFIX)) {
207	adaptToStyleChange(token, event, SWT.ITALIC);
208	} else if (end.equals(PreferenceConstants.EDITOR_STRIKETHROUGH_SUFFIX)) {
209	adaptToStyleChange(token, event, TextAttribute.STRIKETHROUGH);
210	} else if (end.equals(PreferenceConstants.EDITOR_UNDERLINE_SUFFIX)) {
211	adaptToStyleChange(token, event, TextAttribute.UNDERLINE);
212	}
213	}
214	}
215	}
216
217	private void adaptToColorChange(Token token, PropertyChangeEvent event) {
218	RGB rgb= null;
219
220	Object value= event.getNewValue();
221	if (value instanceof RGB)
222	rgb= (RGB) value;
223	else if (value instanceof String)
224	rgb= StringConverter.asRGB((String) value);
225
226	if (rgb != null) {
227
228	String property= event.getProperty();
229	Color color= fColorManager.getColor(property);
230
231	if ((color == null \|\| !rgb.equals(color.getRGB())) && fColorManager instanceof IColorManagerExtension) {
232	IColorManagerExtension ext= (IColorManagerExtension) fColorManager;
233
234	ext.unbindColor(property);
235	ext.bindColor(property, rgb);
236
237	color= fColorManager.getColor(property);
238	}
239
240	Object data= token.getData();
241	if (data instanceof TextAttribute) {
242	TextAttribute oldAttr= (TextAttribute) data;
243	token.setData(new TextAttribute(color, oldAttr.getBackground(), oldAttr.getStyle()));
244	}
245	}
246	}
247
248	private void adaptToStyleChange(Token token, PropertyChangeEvent event, int styleAttribute) {
249	boolean eventValue= false;
250	Object value= event.getNewValue();
251	if (value instanceof Boolean)
252	eventValue= ((Boolean) value).booleanValue();
253	else if (IPreferenceStore.TRUE.equals(value))
254	eventValue= true;
255
256	Object data= token.getData();
257	if (data instanceof TextAttribute) {
258	TextAttribute oldAttr= (TextAttribute) data;
259	boolean activeValue= (oldAttr.getStyle() & styleAttribute) == styleAttribute;
260	if (activeValue != eventValue)
261	token.setData(new TextAttribute(oldAttr.getForeground(), oldAttr.getBackground(), eventValue ? oldAttr.getStyle() \| styleAttribute : oldAttr.getStyle() & ~styleAttribute));
262	}
263	}
264
265	/**
266	* Returns the preference store.
267	*
268	* @return the preference store.
269	*
270	* @since 3.0
271	*/
272	public IPreferenceStore getPreferenceStore() {
273	return fPreferenceStore;
274	}
275	}

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/text/doctools/doxygen/DoxygenHelper.java (+65 lines)
1	package org.eclipse.cdt.internal.ui.text.doctools.doxygen;
2	import java.io.BufferedReader;
3	import java.io.IOException;
4	import java.io.InputStream;
5	import java.io.InputStreamReader;
6	import java.util.ArrayList;
7	import java.util.List;
8
9	import org.eclipse.core.runtime.FileLocator;
10	import org.eclipse.core.runtime.IPath;
11	import org.eclipse.core.runtime.Path;
12	import org.eclipse.jface.preference.IPreferenceStore;
13	import org.eclipse.jface.preference.PreferenceConverter;
14	import org.eclipse.swt.graphics.RGB;
15
16	import org.eclipse.cdt.ui.CUIPlugin;
17	import org.eclipse.cdt.ui.text.doctools.generic.GenericDocTag;
18
19	/**
20	* Controls the life-cycle of the Doxygen comment editor support
21	*/
22	public class DoxygenHelper {
23	/*
24	* TODO - This is a temporary location
25	*/
26	private static final IPath TAGS_CSV= new Path("src/org/eclipse/cdt/internal/ui/text/doctools/doxygen/tags.csv"); //$NON-NLS-1$
27
28	static {
29	// TODO - I'll find a legitimate place to do this
30	IPreferenceStore cuis= CUIPlugin.getDefault().getPreferenceStore();
31	PreferenceConverter.setDefault(cuis, DoxygenHelper.DOXYGEN_MULTI_TOKEN, new RGB(63, 95, 191));
32	PreferenceConverter.setDefault(cuis, DoxygenHelper.DOXYGEN_SINGLE_TOKEN, new RGB(63, 95, 191));
33	PreferenceConverter.setDefault(cuis, DoxygenHelper.DOXYGEN_TAG_RECOGNIZED, new RGB(127, 159, 191));
34	}
35
36
37	private static GenericDocTag[] tags;
38	public static final String DOXYGEN_TAG_RECOGNIZED= "org.eclipse.cdt.internal.ui.text.doctools.doxygen.recognizedTag"; //$NON-NLS-1$
39	public static final String DOXYGEN_SINGLE_TOKEN= "org.eclipse.cdt.internal.ui.text.doctools.doxygen.single"; //$NON-NLS-1$
40	public static final String DOXYGEN_MULTI_TOKEN= "org.eclipse.cdt.internal.ui.text.doctools.doxygen.multi"; //$NON-NLS-1$
41
42	public static GenericDocTag[] getDoxygenTags() {
43	if(tags==null) {
44	try {
45	List temp= new ArrayList();
46	InputStream is= FileLocator.openStream(CUIPlugin.getDefault().getBundle(), TAGS_CSV, false);
47	BufferedReader br= new BufferedReader(new InputStreamReader(is));
48	StringBuffer content= new StringBuffer();
49	for(String line= br.readLine(); line!=null; line= br.readLine()) {
50	content.append(line+"\n"); //$NON-NLS-1$
51	}
52	String[] values= content.toString().split("(\\s),(\\s)"); //$NON-NLS-1$
53
54	for(int i=0; i+1<values.length; i+=2) {
55	temp.add(new GenericDocTag(values[i], values[i+1]));
56	}
57	tags= (GenericDocTag[]) temp.toArray(new GenericDocTag[temp.size()]);
58	} catch(IOException ioe) {
59
60	}
61
62	}
63	return tags;
64	}
65	}

Added Link Here

(-)src/org/eclipse/cdt/internal/ui/text/doctools/docpp/tags.csv (+19 lines)
1	args,,
2	author,,
3	deprecated,,
4	doc,,
5	exception,,
6	field,,
7	friends,,
8	invariant,,
9	memo,,
10	name,,
11	param,,
12	postcondition,,
13	precondition,,
14	return,,
15	see,,
16	since,,
17	type,,
18	version,,
19

Added Link Here

(-)schema/DocCommentOwner.exsd (+124 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.cdt.ui">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.cdt.ui" id="DocCommentOwner" name="DocCommentOwner"/>
7	</appInfo>
8	<documentation>
9	[Enter description of this extension point.]
10	</documentation>
11	</annotation>
12
13	<element name="extension">
14	<complexType>
15	<choice>
16	<element ref="owner"/>
17	</choice>
18	<attribute name="point" type="string" use="required">
19	<annotation>
20	<documentation>
21
22	</documentation>
23	</annotation>
24	</attribute>
25	<attribute name="id" type="string">
26	<annotation>
27	<documentation>
28
29	</documentation>
30	</annotation>
31	</attribute>
32	<attribute name="name" type="string">
33	<annotation>
34	<documentation>
35
36	</documentation>
37	<appInfo>
38	<meta.attribute translatable="true"/>
39	</appInfo>
40	</annotation>
41	</attribute>
42	</complexType>
43	</element>
44
45	<element name="owner">
46	<complexType>
47	<attribute name="id" type="string" use="required">
48	<annotation>
49	<documentation>
50
51	</documentation>
52	</annotation>
53	</attribute>
54	<attribute name="name" type="string" use="required">
55	<annotation>
56	<documentation>
57
58	</documentation>
59	<appInfo>
60	<meta.attribute translatable="true"/>
61	</appInfo>
62	</annotation>
63	</attribute>
64	<attribute name="multiline" type="string" use="required">
65	<annotation>
66	<documentation>
67
68	</documentation>
69	<appInfo>
70	<meta.attribute kind="java" basedOn=":org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration"/>
71	</appInfo>
72	</annotation>
73	</attribute>
74	<attribute name="singleline" type="string" use="required">
75	<annotation>
76	<documentation>
77
78	</documentation>
79	<appInfo>
80	<meta.attribute kind="java" basedOn=":org.eclipse.cdt.ui.text.doctools.IDocCommentViewerConfiguration"/>
81	</appInfo>
82	</annotation>
83	</attribute>
84	</complexType>
85	</element>
86
87	<annotation>
88	<appInfo>
89	<meta.section type="since"/>
90	</appInfo>
91	<documentation>
92	5.0
93	</documentation>
94	</annotation>
95
96	<annotation>
97	<appInfo>
98	<meta.section type="examples"/>
99	</appInfo>
100	<documentation>
101	[Enter extension point usage example here.]
102	</documentation>
103	</annotation>
104
105	<annotation>
106	<appInfo>
107	<meta.section type="apiInfo"/>
108	</appInfo>
109	<documentation>
110	[Enter API information here.]
111	</documentation>
112	</annotation>
113
114	<annotation>
115	<appInfo>
116	<meta.section type="implementation"/>
117	</appInfo>
118	<documentation>
119	[Enter information about supplied implementation of this extension point.]
120	</documentation>
121	</annotation>
122
123
124	</schema>

Added Link Here

(-)src/org/eclipse/cdt/ui/text/TaskTagRule.java (+119 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	* Anton Leherbauer (Wind River Systems)
11	* Sergey Prigogin (Google)
12	* Andrew Ferguson (Symbian)
13	*******************************************************************************/
14	package org.eclipse.cdt.ui.text;
15
16	import org.eclipse.core.runtime.Preferences;
17	import org.eclipse.jface.preference.IPreferenceStore;
18	import org.eclipse.jface.text.rules.IToken;
19	import org.eclipse.jface.text.rules.IWordDetector;
20	import org.eclipse.jface.text.rules.Token;
21	import org.eclipse.jface.text.rules.WordRule;
22	import org.eclipse.jface.util.PropertyChangeEvent;
23
24	import org.eclipse.cdt.core.CCorePreferenceConstants;
25	import org.eclipse.cdt.ui.IPropertyChangeParticipant;
26
27	/**
28	*
29	* Which words should be recognized as task tags is specified under {@link CCorePreferenceConstants#TODO_TASK_TAGS} as a
30	* comma delimited list.
31	*
32	* @see CCorePreferenceConstants#TODO_TASK_TAGS
33	* @since 5.0
34	*/
35	public final class TaskTagRule extends WordRule implements IPropertyChangeParticipant {
36	private static class TaskTagDetector implements IWordDetector {
37	public boolean isWordStart(char c) {
38	return Character.isLetter(c);
39	}
40	public boolean isWordPart(char c) {
41	return Character.isLetter(c);
42	}
43	}
44
45	/**
46	* Convenience method for extracting a list of words that should be recognized as
47	* task labels from an {@link IPreferenceStore} and a backup {@link Preferences}
48	* @param preferenceStore
49	* @param corePreferences
50	* @return a list of words that should be recognized as task labels in the format
51	* expected by TaskTagRule
52	*/
53	public static String getTaskWords(IPreferenceStore preferenceStore, Preferences corePreferences) {
54	String result= null;
55	if (preferenceStore.contains(CCorePreferenceConstants.TODO_TASK_TAGS)) {
56	result= preferenceStore.getString(CCorePreferenceConstants.TODO_TASK_TAGS);
57	} else if (corePreferences != null) {
58	result= corePreferences.getString(CCorePreferenceConstants.TODO_TASK_TAGS);
59	}
60	return result;
61	}
62
63	private IToken fToken;
64
65	/**
66	* Creates a new task tag rule
67	* @param token the token to return for words recognized as task tags
68	* @param taskWords a comma delimited list of words to recognize as task tags
69	*/
70	public TaskTagRule(IToken token, String taskWords) {
71	super(new TaskTagDetector(), Token.UNDEFINED);
72	fToken= token;
73	if( taskWords!= null) {
74	addTaskTags(taskWords);
75	}
76	}
77
78	/**
79	* Removes the current list of words that should be
80	* recognized as task tags.
81	*/
82	public void clearTaskTags() {
83	fWords.clear();
84	}
85
86	/**
87	* Adds tags from the specified string as task tags.
88	* @param value a comma delimited list of words to recognize as task tags
89	*/
90	public void addTaskTags(String value) {
91	String[] tasks= value.split(","); //$NON-NLS-1$
92	for (int i= 0; i < tasks.length; i++) {
93	if (tasks[i].length() > 0) {
94	addWord(tasks[i], fToken);
95	}
96	}
97	}
98
99	/*
100	* @see org.eclipse.cdt.ui.IPropertyChangeParticipant#affectsBehavior(org.eclipse.jface.util.PropertyChangeEvent)
101	*/
102	public boolean affectsBehavior(PropertyChangeEvent event) {
103	return event.getProperty().equals(CCorePreferenceConstants.TODO_TASK_TAGS);
104	}
105
106	/*
107	* @see org.eclipse.cdt.ui.IPropertyChangeParticipant#adaptToPreferenceChange(org.eclipse.jface.util.PropertyChangeEvent)
108	*/
109	public void adaptToPreferenceChange(PropertyChangeEvent event) {
110	if (event.getProperty().equals(CCorePreferenceConstants.TODO_TASK_TAGS)) {
111	Object value= event.getNewValue();
112
113	if (value instanceof String) {
114	clearTaskTags();
115	addTaskTags((String) value);
116	}
117	}
118	}
119	}

Added Link Here

(-)src/org/eclipse/cdt/ui/dialogs/DocCommentOwnerComposite.java (+62 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Symbian Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Andrew Ferguson (Symbian) - Initial implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.ui.dialogs;
12
13	import org.eclipse.jface.layout.GridDataFactory;
14	import org.eclipse.swt.SWT;
15	import org.eclipse.swt.layout.GridData;
16	import org.eclipse.swt.layout.GridLayout;
17	import org.eclipse.swt.widgets.Composite;
18	import org.eclipse.swt.widgets.Group;
19	import org.eclipse.swt.widgets.Label;
20
21	import org.eclipse.cdt.ui.text.doctools.IDocCommentOwner;
22	import org.eclipse.cdt.utils.ui.controls.ControlFactory;
23
24	public class DocCommentOwnerComposite extends Composite {
25	protected DocCommentOwnerCombo fDocCombo;
26	protected Label desc, comboLabel;
27	protected Group group;
28
29	public DocCommentOwnerComposite(Composite parent, IDocCommentOwner initialOwner, String description, String label) {
30	super(parent, SWT.NONE);
31	GridLayout gl= new GridLayout();
32	gl.marginHeight= gl.marginWidth= 0;
33	setLayout(gl);
34
35	group = ControlFactory.createGroup(this, DialogsMessages.DocCommentOwnerComposite_DocumentationToolGroupTitle, 2);
36	group.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());
37
38	desc= new Label(group, SWT.WRAP);
39	GridData gd = GridDataFactory.fillDefaults().grab(false, false).span(2, 1).create();
40	gd.widthHint= 150;
41	desc.setText(description);
42	desc.setLayoutData(gd);
43
44	comboLabel= new Label(group, SWT.NONE);
45	comboLabel.setText(label);
46
47	fDocCombo= new DocCommentOwnerCombo(group, SWT.NONE, initialOwner) {};
48	gd = GridDataFactory.fillDefaults().grab(true, false).create();
49	fDocCombo.setLayoutData(gd);
50	}
51
52	public IDocCommentOwner getSelectedDocCommentOwner() {
53	return fDocCombo.getSelectedDocCommentOwner();
54	}
55
56	public void setEnabled(boolean enabled) {
57	desc.setEnabled(enabled);
58	comboLabel.setEnabled(enabled);
59	fDocCombo.setEnabled(enabled);
60	group.setEnabled(enabled);
61	}
62	}

Lines 1-5 Link Here

(-)src/org/eclipse/core/internal/filebuffers/TextFileBufferManager.java (-16 / +20 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Andrew Ferguson (Symbian)
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.core.internal.filebuffers;	12	package org.eclipse.core.internal.filebuffers;
12		13
Lines 18-28 Link Here
18	import java.util.List;	19	import java.util.List;
19	import java.util.Map;	20	import java.util.Map;
20		21
		22	import org.eclipse.core.filebuffers.IAnnotationModelFactory;
		23	import org.eclipse.core.filebuffers.IDocumentFactory;
		24	import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
		25	import org.eclipse.core.filebuffers.IDocumentSetupParticipantExtension;
		26	import org.eclipse.core.filebuffers.IFileBuffer;
		27	import org.eclipse.core.filebuffers.IFileBufferListener;
		28	import org.eclipse.core.filebuffers.IFileBufferStatusCodes;
		29	import org.eclipse.core.filebuffers.ISynchronizationContext;
		30	import org.eclipse.core.filebuffers.ITextFileBuffer;
		31	import org.eclipse.core.filebuffers.ITextFileBufferManager;
		32	import org.eclipse.core.filebuffers.LocationKind;
21	import org.eclipse.core.filesystem.EFS;	33	import org.eclipse.core.filesystem.EFS;
22	import org.eclipse.core.filesystem.IFileInfo;	34	import org.eclipse.core.filesystem.IFileInfo;
23	import org.eclipse.core.filesystem.IFileStore;	35	import org.eclipse.core.filesystem.IFileStore;
24	import org.eclipse.core.filesystem.URIUtil;	36	import org.eclipse.core.filesystem.URIUtil;
25
26	import org.eclipse.core.runtime.Assert;	37	import org.eclipse.core.runtime.Assert;
27	import org.eclipse.core.runtime.CoreException;	38	import org.eclipse.core.runtime.CoreException;
28	import org.eclipse.core.runtime.IPath;	39	import org.eclipse.core.runtime.IPath;
Lines 35-52 Link Here
35	import org.eclipse.core.runtime.content.IContentDescription;	46	import org.eclipse.core.runtime.content.IContentDescription;
36	import org.eclipse.core.runtime.content.IContentType;	47	import org.eclipse.core.runtime.content.IContentType;
37	import org.eclipse.core.runtime.content.IContentTypeManager;	48	import org.eclipse.core.runtime.content.IContentTypeManager;
38
39	import org.eclipse.core.filebuffers.IAnnotationModelFactory;
40	import org.eclipse.core.filebuffers.IDocumentFactory;
41	import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
42	import org.eclipse.core.filebuffers.IFileBuffer;
43	import org.eclipse.core.filebuffers.IFileBufferListener;
44	import org.eclipse.core.filebuffers.IFileBufferStatusCodes;
45	import org.eclipse.core.filebuffers.ISynchronizationContext;
46	import org.eclipse.core.filebuffers.ITextFileBuffer;
47	import org.eclipse.core.filebuffers.ITextFileBufferManager;
48	import org.eclipse.core.filebuffers.LocationKind;
49
50	import org.eclipse.jface.text.IDocument;	49	import org.eclipse.jface.text.IDocument;
51	import org.eclipse.jface.text.IDocumentExtension4;	50	import org.eclipse.jface.text.IDocumentExtension4;
52	import org.eclipse.jface.text.source.IAnnotationModel;	51	import org.eclipse.jface.text.source.IAnnotationModel;
Lines 432-438 Link Here
432	* @see org.eclipse.core.filebuffers.ITextFileBufferManager#createEmptyDocument(org.eclipse.core.runtime.IPath, org.eclipse.core.filebuffers.LocationKind)	431	* @see org.eclipse.core.filebuffers.ITextFileBufferManager#createEmptyDocument(org.eclipse.core.runtime.IPath, org.eclipse.core.filebuffers.LocationKind)
433	* @since 3.3	432	* @since 3.3
434	*/	433	*/
435	public IDocument createEmptyDocument(IPath location, LocationKind locationKind) {	434	public IDocument createEmptyDocument(final IPath location, final LocationKind locationKind) {
436	final IDocument[] runnableResult= new IDocument[1];	435	final IDocument[] runnableResult= new IDocument[1];
437	if (location != null) {	436	if (location != null) {
438	final IDocumentFactory factory= fRegistry.getDocumentFactory(location, locationKind);	437	final IDocumentFactory factory= fRegistry.getDocumentFactory(location, locationKind);
Lines 473-479 Link Here
473	final IDocumentSetupParticipant participant= participants[i];	472	final IDocumentSetupParticipant participant= participants[i];
474	ISafeRunnable runnable= new ISafeRunnable() {	473	ISafeRunnable runnable= new ISafeRunnable() {
475	public void run() throws Exception {	474	public void run() throws Exception {
476	participant.setup(document);	475	if(participant instanceof IDocumentSetupParticipantExtension) {
		476	IDocumentSetupParticipantExtension extParticipant= (IDocumentSetupParticipantExtension) participant;
		477	extParticipant.setup(document, location, locationKind);
		478	} else {
		479	participant.setup(document);
		480	}
477	if (document.getDocumentPartitioner() != null) {	481	if (document.getDocumentPartitioner() != null) {
478	String message= NLSUtility.format(FileBuffersMessages.TextFileBufferManager_warning_documentSetupInstallsDefaultPartitioner, participant.getClass());	482	String message= NLSUtility.format(FileBuffersMessages.TextFileBufferManager_warning_documentSetupInstallsDefaultPartitioner, participant.getClass());
479	IStatus status= new Status(IStatus.WARNING, FileBuffersPlugin.PLUGIN_ID, IStatus.OK, message, null);	483	IStatus status= new Status(IStatus.WARNING, FileBuffersPlugin.PLUGIN_ID, IStatus.OK, message, null);

Lines 8-13 Link Here

(-)ui/org/eclipse/cdt/ui/tests/text/CAutoIndentTest.java (-197 / +6 lines)
8	* Contributors:	8	* Contributors:
9	* Anton Leherbauer (Wind River Systems) - initial API and implementation	9	* Anton Leherbauer (Wind River Systems) - initial API and implementation
10	* Sergey Prigogin, Google	10	* Sergey Prigogin, Google
		11	* Andrew Ferguson (Symbian)
11	*******************************************************************************/	12	*******************************************************************************/
12		13
13	package org.eclipse.cdt.ui.tests.text;	14	package org.eclipse.cdt.ui.tests.text;
Lines 16-22 Link Here
16	import java.util.Collections;	17	import java.util.Collections;
17	import java.util.HashMap;	18	import java.util.HashMap;
18	import java.util.List;	19	import java.util.List;
19	import java.util.Map;
20		20
21	import junit.framework.Test;	21	import junit.framework.Test;
22	import junit.framework.TestSuite;	22	import junit.framework.TestSuite;
Lines 26-239 Link Here
26	import org.eclipse.core.runtime.Plugin;	26	import org.eclipse.core.runtime.Plugin;
27	import org.eclipse.jface.text.BadLocationException;	27	import org.eclipse.jface.text.BadLocationException;
28	import org.eclipse.jface.text.Document;	28	import org.eclipse.jface.text.Document;
29	import org.eclipse.jface.text.DocumentCommand;
30	import org.eclipse.jface.text.IAutoEditStrategy;
31	import org.eclipse.jface.text.IDocument;	29	import org.eclipse.jface.text.IDocument;
32	import org.eclipse.jface.text.IRegion;
33	import org.eclipse.jface.text.TextUtilities;
34		30
35	import org.eclipse.cdt.core.CCorePlugin;	31	import org.eclipse.cdt.core.CCorePlugin;
36	import org.eclipse.cdt.core.testplugin.util.BaseTestCase;
37	import org.eclipse.cdt.ui.CUIPlugin;	32	import org.eclipse.cdt.ui.CUIPlugin;
38	import org.eclipse.cdt.ui.text.ICPartitions;	33	import org.eclipse.cdt.ui.text.ICPartitions;
		34	import org.eclipse.cdt.ui.text.doctools.DefaultMultilineCommentAutoEditStrategy;
39		35
40	import org.eclipse.cdt.internal.formatter.DefaultCodeFormatterOptions;	36	import org.eclipse.cdt.internal.formatter.DefaultCodeFormatterOptions;
41		37
42	import org.eclipse.cdt.internal.ui.text.CAutoIndentStrategy;	38	import org.eclipse.cdt.internal.ui.text.CAutoIndentStrategy;
43	import org.eclipse.cdt.internal.ui.text.CCommentAutoIndentStrategy;
44	import org.eclipse.cdt.internal.ui.text.CTextTools;	39	import org.eclipse.cdt.internal.ui.text.CTextTools;
45		40
46	/**	41	/**
47	* Testing the auto indent strategies.	42	* Testing the auto indent strategies.
48	*/	43	*/
49	public class CAutoIndentTest extends BaseTestCase {	44	public class CAutoIndentTest extends AbstractAutoEditTest {
50
51	/**
52	* Helper class to test the auto-edit strategies on a document.
53	*/
54	static class AutoEditTester {
55
56	private Map fStrategyMap = new HashMap();
57	private IDocument fDoc;
58	private String fPartitioning;
59	private int fCaretOffset;
60
61	public AutoEditTester(IDocument doc, String partitioning) {
62	super();
63	fDoc = doc;
64	fPartitioning = partitioning;
65	}
66
67	public void setAutoEditStrategy(String contentType, IAutoEditStrategy aes) {
68	fStrategyMap.put(contentType, aes);
69	}
70
71	public IAutoEditStrategy getAutoEditStrategy(String contentType) {
72	return (IAutoEditStrategy)fStrategyMap.get(contentType);
73	}
74
75	/**
76	* Empties the document, and returns the caret to the origin (0,0)
77	*/
78	public void reset() {
79	try {
80	goTo(0,0);
81	fDoc.set("");
82	} catch(BadLocationException ble) {
83	fail(ble.getMessage());
84	}
85	}
86
87	public void type(String text) throws BadLocationException {
88	for (int i = 0; i < text.length(); ++i) {
89	type(text.charAt(i));
90	}
91	}
92
93	public void type(char c) throws BadLocationException {
94	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, new String(new char[] { c }));
95	customizeDocumentCommand(command);
96	fCaretOffset = command.exec(fDoc);
97	}
98
99	private void customizeDocumentCommand(TestDocumentCommand command) throws BadLocationException {
100	IAutoEditStrategy aes = getAutoEditStrategy(getContentType());
101	if (aes != null) {
102	aes.customizeDocumentCommand(fDoc, command);
103	}
104	}
105
106	public void type(int offset, String text) throws BadLocationException {
107	fCaretOffset = offset;
108	type(text);
109	}
110
111	public void type(int offset, char c) throws BadLocationException {
112	fCaretOffset = offset;
113	type(c);
114	}
115
116	public void paste(String text) throws BadLocationException {
117	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, text);
118	customizeDocumentCommand(command);
119	fCaretOffset = command.exec(fDoc);
120	}
121
122	public void paste(int offset, String text) throws BadLocationException {
123	fCaretOffset = offset;
124	paste(text);
125	}
126
127	public void backspace(int n) throws BadLocationException {
128	for (int i = 0; i < n; ++i) {
129	backspace();
130	}
131	}
132
133	public void backspace() throws BadLocationException {
134	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset - 1, 1, ""); //$NON-NLS-1$
135	customizeDocumentCommand(command);
136	fCaretOffset = command.exec(fDoc);
137	}
138
139	public int getCaretOffset() {
140	return fCaretOffset;
141	}
142
143	public int setCaretOffset(int offset) {
144	fCaretOffset = offset;
145	if (fCaretOffset < 0)
146	fCaretOffset = 0;
147	else if (fCaretOffset > fDoc.getLength())
148	fCaretOffset = fDoc.getLength();
149	return fCaretOffset;
150	}
151
152	/**
153	* Moves caret right or left by the given number of characters.
154	*
155	* @param shift Move distance.
156	* @return New caret offset.
157	*/
158	public int moveCaret(int shift) {
159	return setCaretOffset(fCaretOffset + shift);
160	}
161
162	public int goTo(int line) throws BadLocationException {
163	fCaretOffset = fDoc.getLineOffset(line);
164	return fCaretOffset;
165	}
166
167	public int goTo(int line, int column) throws BadLocationException {
168	if (column < 0 \|\| column > fDoc.getLineLength(line)) {
169	throw new BadLocationException("No column " + column + " in line " + line); //$NON-NLS-1$ $NON-NLS-2$
170	}
171	fCaretOffset = fDoc.getLineOffset(line) + column;
172	return fCaretOffset;
173	}
174
175	public int getCaretLine() throws BadLocationException {
176	return fDoc.getLineOfOffset(fCaretOffset);
177	}
178
179	public int getCaretColumn() throws BadLocationException {
180	IRegion region = fDoc.getLineInformationOfOffset(fCaretOffset);
181	return fCaretOffset - region.getOffset();
182	}
183
184	public char getChar() throws BadLocationException {
185	return getChar(0);
186	}
187
188	public char getChar(int i) throws BadLocationException {
189	return fDoc.getChar(fCaretOffset+i);
190	}
191
192	public String getLine() throws BadLocationException {
193	return getLine(0);
194	}
195
196	public String getLine(int i) throws BadLocationException {
197	IRegion region = fDoc.getLineInformation(getCaretLine() + i);
198	return fDoc.get(region.getOffset(), region.getLength());
199	}
200
201	public String getContentType() throws BadLocationException {
202	return getContentType(0);
203	}
204
205	public String getContentType(int i) throws BadLocationException {
206	return TextUtilities.getContentType(fDoc, fPartitioning, fCaretOffset + i, false);
207	}
208	}
209
210	/**
211	* A DocumentCommand with public constructor and exec method.
212	*/
213	static class TestDocumentCommand extends DocumentCommand {
214
215	public TestDocumentCommand(int offset, int length, String text) {
216	super();
217	doit = true;
218	this.text = text;
219
220	this.offset = offset;
221	this.length = length;
222
223	owner = null;
224	caretOffset = -1;
225	}
226
227	/**
228	* Returns new caret position.
229	*/
230	public int exec(IDocument doc) throws BadLocationException {
231	doc.replace(offset, length, text);
232	return caretOffset != -1 ?
233	caretOffset :
234	offset + (text == null ? 0 : text.length());
235	}
236	}
237		45
238	private HashMap fOptions;	46	private HashMap fOptions;
239	private List fStatusLog;	47	private List fStatusLog;
Lines 289-296 Link Here
289	IDocument doc = new Document();	97	IDocument doc = new Document();
290	textTools.setupCDocument(doc);	98	textTools.setupCDocument(doc);
291	AutoEditTester tester = new AutoEditTester(doc, ICPartitions.C_PARTITIONING);	99	AutoEditTester tester = new AutoEditTester(doc, ICPartitions.C_PARTITIONING);
		100
292	tester.setAutoEditStrategy(IDocument.DEFAULT_CONTENT_TYPE, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));	101	tester.setAutoEditStrategy(IDocument.DEFAULT_CONTENT_TYPE, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));
293	tester.setAutoEditStrategy(ICPartitions.C_MULTI_LINE_COMMENT, new CCommentAutoIndentStrategy());	102	tester.setAutoEditStrategy(ICPartitions.C_MULTI_LINE_COMMENT, new DefaultMultilineCommentAutoEditStrategy());
294	tester.setAutoEditStrategy(ICPartitions.C_PREPROCESSOR, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));	103	tester.setAutoEditStrategy(ICPartitions.C_PREPROCESSOR, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));
295	return tester;	104	return tester;
296	}	105	}
Lines 385-391 Link Here
385	public void testCCommentAutoIndent() throws BadLocationException {	194	public void testCCommentAutoIndent() throws BadLocationException {
386	AutoEditTester tester = createAutoEditTester(); //$NON-NLS-1$	195	AutoEditTester tester = createAutoEditTester(); //$NON-NLS-1$
387	tester.type("/*\n"); //$NON-NLS-1$	196	tester.type("/*\n"); //$NON-NLS-1$
388	assertEquals(ICPartitions.C_MULTI_LINE_COMMENT, tester.getContentType(-1));	197	assertEquals(ICPartitions.C_MULTI_LINE_COMMENT, tester.getContentType(tester.getCaretOffset()-1));
389	assertEquals(1, tester.getCaretLine());	198	assertEquals(1, tester.getCaretLine());
390	assertEquals(3, tester.getCaretColumn());	199	assertEquals(3, tester.getCaretColumn());
391	assertEquals(" * ", tester.getLine()); //$NON-NLS-1$	200	assertEquals(" * ", tester.getLine()); //$NON-NLS-1$

Lines 32-41 Link Here

(-)plugin.xml (-3 / +85 lines)
32	<perspectiveExtension	32	<perspectiveExtension
33	targetID="org.eclipse.ui.resourcePerspective">	33	targetID="org.eclipse.ui.resourcePerspective">
34	<view	34	<view
		35	id="org.eclipse.cdt.ui.tests.DOMAST.DOMAST"
35	ratio="0.5"	36	ratio="0.5"
36	relative="org.eclipse.ui.views.TaskList"
37	relationship="right"	37	relationship="right"
38	id="org.eclipse.cdt.ui.tests.DOMAST.DOMAST">	38	relative="org.eclipse.ui.views.TaskList">
39	</view>	39	</view>
40	</perspectiveExtension>	40	</perspectiveExtension>
41	</extension>	41	</extension>
Lines 115-119 Link Here
115	projectType="org.eclipse.cdt.build.core.buildArtefactType.exe">	115	projectType="org.eclipse.cdt.build.core.buildArtefactType.exe">
116	</template>	116	</template>
117	</extension>	117	</extension>
118		118
		119
		120	<!-- documentation tool comment test owners -->
		121	<extension
		122	point="org.eclipse.cdt.ui.DocCommentOwner">
		123	<owner id="org.cdt.test.DCOM1"
		124	name="Test comment owner1"
		125	singleline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
		126	multiline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
		127	/>
		128	</extension>
		129	<extension
		130	point="org.eclipse.cdt.ui.DocCommentOwner">
		131	<owner id="org.cdt.test.DCOM2"
		132	name="Test comment owner1"
		133	singleline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
		134	multiline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
		135	/>
		136	</extension>
		137	<extension
		138	point="org.eclipse.cdt.ui.DocCommentOwner">
		139	<owner
		140	id="org.cdt.test.DCOM3"
		141	multiline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration"
		142	name="Test comment owner1"
		143	singleline="org.eclipse.cdt.internal.ui.text.doctools.NullDocCommentViewerConfiguration">
		144	</owner>
		145	</extension>
		146	<extension
		147	point="org.eclipse.cdt.ui.DocCommentOwner">
		148	<owner
		149	id="org.cdt.test.ownerA"
		150	multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$A"
		151	name="name_A"
		152	singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$A">
		153	</owner>
		154	</extension>
		155	<extension
		156	point="org.eclipse.cdt.ui.DocCommentOwner">
		157	<owner
		158	id="org.cdt.test.ownerB"
		159	multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$B"
		160	name="name_B"
		161	singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$B">
		162	</owner>
		163	</extension>
		164	<extension
		165	point="org.eclipse.cdt.ui.DocCommentOwner">
		166	<owner
		167	id="org.cdt.test.ownerC"
		168	multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$C"
		169	name="name_C"
		170	singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$C">
		171	</owner>
		172	</extension>
		173	<extension
		174	point="org.eclipse.cdt.ui.DocCommentOwner">
		175	<owner
		176	id="org.cdt.test.ownerABC"
		177	multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$ABC"
		178	name="name_ABC"
		179	singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$ABC">
		180	</owner>
		181	</extension>
		182	<extension
183	point="org.eclipse.cdt.ui.DocCommentOwner">
184	<owner
185	id="org.cdt.test.ownerBDFG"
186	multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$BDFG"
187	name="name_BDFG"
188	singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$BDFG">
189	</owner>
190	</extension>
191	<extension
192	point="org.eclipse.cdt.ui.DocCommentOwner">
193	<owner
194	id="org.cdt.test.ownerPUNC"
195	multiline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$PUNC"
196	name="name_PUNC"
197	singleline="org.eclipse.cdt.ui.tests.text.doctools.TestGenericTagConfiguration$PUNC">
198	</owner>
199	</extension>
200
119	</plugin>	201	</plugin>

Added Link Here

(-)ui/org/eclipse/cdt/ui/tests/text/doctools/DocCommentTestSuite.java (+28 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Symbian Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Andrew Ferguson (Symbian) - Initial implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.ui.tests.text.doctools;
12
13	import junit.framework.TestSuite;
14
15	public class DocCommentTestSuite extends TestSuite {
16
17	public static TestSuite suite() {
18	return new DocCommentTestSuite();
19	}
20
21	public DocCommentTestSuite() {
22	super(DocCommentTestSuite.class.getName());
23
24	// partitioning tests
25	addTest(CommentOwnerManagerTests.suite());
26	addTest(DocCommentHighlightingTest.suite());
27	}
28	}

Added Link Here

(-)ui/org/eclipse/cdt/ui/tests/text/DefaultCCommentAutoEditStrategyTest.java (+629 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 Wind River Systems, Inc. and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Anton Leherbauer (Wind River Systems) - initial API and implementation
10	* Sergey Prigogin, Google
11	* Andrew Ferguson (Symbian)
12	*******************************************************************************/
13
14	package org.eclipse.cdt.ui.tests.text;
15
16	import java.io.IOException;
17	import java.util.HashMap;
18
19	import junit.framework.Test;
20
21	import org.eclipse.core.resources.IFile;
22	import org.eclipse.core.runtime.CoreException;
23	import org.eclipse.jface.text.BadLocationException;
24	import org.eclipse.jface.text.Document;
25	import org.eclipse.jface.text.IDocument;
26
27	import org.eclipse.cdt.core.CCorePlugin;
28	import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
29	import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
30	import org.eclipse.cdt.core.model.ICProject;
31	import org.eclipse.cdt.core.testplugin.CProjectHelper;
32	import org.eclipse.cdt.core.testplugin.util.TestSourceReader;
33	import org.eclipse.cdt.ui.CUIPlugin;
34	import org.eclipse.cdt.ui.testplugin.CTestPlugin;
35	import org.eclipse.cdt.ui.text.ICPartitions;
36	import org.eclipse.cdt.ui.text.doctools.DefaultMultilineCommentAutoEditStrategy;
37
38	import org.eclipse.cdt.internal.ui.text.CAutoIndentStrategy;
39	import org.eclipse.cdt.internal.ui.text.CTextTools;
40
41
42	/**
43	* Testing the auto indent strategies.
44	*/
45	public class DefaultCCommentAutoEditStrategyTest extends AbstractAutoEditTest {
46	private HashMap fOptions;
47
48	/**
49	* @param name
50	*/
51	public DefaultCCommentAutoEditStrategyTest(String name) {
52	super(name);
53	}
54
55	public static Test suite() {
56	return suite(DefaultCCommentAutoEditStrategyTest.class);
57	}
58
59	protected void setUp() throws Exception {
60	super.setUp();
61	// Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
62	// shell.forceActive();
63	// shell.forceFocus();
64	fOptions= CCorePlugin.getOptions();
65	}
66
67	/*
68	* @see junit.framework.TestCase#tearDown()
69	*/
70	protected void tearDown() throws Exception {
71	CCorePlugin.setOptions(fOptions);
72	super.tearDown();
73	}
74
75	private AutoEditTester createAutoEditTester() {
76	CTextTools textTools = CUIPlugin.getDefault().getTextTools();
77	IDocument doc = new Document();
78	textTools.setupCDocument(doc);
79	AutoEditTester tester = new AutoEditTester(doc, ICPartitions.C_PARTITIONING);
80
81
82	tester.setAutoEditStrategy(IDocument.DEFAULT_CONTENT_TYPE, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));
83	tester.setAutoEditStrategy(ICPartitions.C_MULTI_LINE_COMMENT, new DefaultMultilineCommentAutoEditStrategy());
84	tester.setAutoEditStrategy(ICPartitions.C_PREPROCESSOR, new CAutoIndentStrategy(ICPartitions.C_PARTITIONING, null));
85	return tester;
86	}
87
88	public void testIsMultilineNew() throws BadLocationException {
89	DefaultMultilineCommentAutoEditStrategy ds= new DefaultMultilineCommentAutoEditStrategy();
90	CTextTools textTools = CUIPlugin.getDefault().getTextTools();
91	IDocument doc = new Document();
92	textTools.setupCDocument(doc);
93
94	doc.set(" /* ");
95	assertTrue(ds.shouldCloseMultiline(doc, 3));
96	doc.set(" /* \n");
97	assertTrue(ds.shouldCloseMultiline(doc, 3));
98	assertTrue(ds.shouldCloseMultiline(doc, 5));
99	doc.set(" /* \n ");
100	assertTrue(ds.shouldCloseMultiline(doc, 3));
101	assertTrue(ds.shouldCloseMultiline(doc, 6));
102	doc.set(" /* */");
103	assertFalse(ds.shouldCloseMultiline(doc, 5));
104	doc.set(" /* */ ");
105	assertFalse(ds.shouldCloseMultiline(doc, 5));
106	doc.set(" /* \n\n */ ");
107	assertFalse(ds.shouldCloseMultiline(doc, 5));
108	doc.set(" /* \n\n / \n /");
109	assertTrue(ds.shouldCloseMultiline(doc, 14));
110	doc.set(" /* \n\n / \n / ");
111	assertTrue(ds.shouldCloseMultiline(doc, 14));
112	doc.set(" /* \n\n / \n / \n");
113	assertTrue(ds.shouldCloseMultiline(doc, 14));
114	doc.set(" /* /* \n\n / \n / \n");
115	assertTrue(ds.shouldCloseMultiline(doc, 3));
116	doc.set(" /* \n/* \n\n / \n / \n");
117	assertTrue(ds.shouldCloseMultiline(doc, 3));
118	doc.set(" /* \n\n/* \n\n / \n / \n");
119	assertTrue(ds.shouldCloseMultiline(doc, 3));
120	doc.set(" /* \n\n/* \n\n / \n / \n");
121	assertTrue(ds.shouldCloseMultiline(doc, 3));
122	doc.set(" /* \n\n / / \n\n / \n / \n");
123	assertFalse(ds.shouldCloseMultiline(doc, 3));
124	doc.set(" /\n /\n * \n * \n */\n");
125	assertFalse(ds.shouldCloseMultiline(doc, 8));
126	}
127
128	// /*X
129
130	// /*
131	// * X
132	// */
133	public void testInsertNewLine1() {
134	assertNewLineBehaviour();
135	}
136
137	// /*X
138
139	// /*
140	// * X
141	// */
142	public void testInsertNewLine2() {
143	assertNewLineBehaviour();
144	}
145
146	// class A {}; /*X
147
148	// class A {}; /*
149	// X
150	public void testInsertNewLine3() {
151	assertNewLineBehaviour();
152	}
153
154	// class A {
155	// /*X
156	// };
157
158	// class A {
159	// /*
160	// * X
161	// */
162	// };
163	public void testInsertNewLine4() {
164	assertNewLineBehaviour();
165	}
166
167	// class A {
168	// /* X
169	// };
170
171	// class A {
172	// /*
173	// * X
174	// */
175	// };
176	public void testInsertNewLine5() {
177	assertNewLineBehaviour();
178	}
179
180
181
182	// class A {
183	// /*X
184	// *
185	// */
186	// };
187
188	// class A {
189	// /*
190	// * X
191	// *
192	// */
193	// };
194	public void testInsertNewLine6() {
195	assertNewLineBehaviour();
196	}
197
198	// class A {
199	// /*
200	// *X
201	// */
202	// };
203
204	// class A {
205	// /*
206	// *
207	// *X
208	// */
209	// };
210	public void testInsertNewLine7() {
211	assertNewLineBehaviour();
212	}
213
214	// class A {
215	// /*
216	// *X
217	// */
218	// };
219
220	// class A {
221	// /*
222	// *
223	// *X
224	// */
225	// };
226	public void testInsertNewLine8() {
227	assertNewLineBehaviour();
228	}
229
230	// class A {
231	// /*
232	// * abcd def ghiX
233	// */
234	// };
235
236	// class A {
237	// /*
238	// * abcd def ghi
239	// * X
240	// */
241	// };
242	public void testInsertNewLine9() {
243	assertNewLineBehaviour();
244	}
245
246	// class A {
247	// /*
248	// * abcd deXf ghi
249	// */
250	// };
251
252	// class A {
253	// /*
254	// * abcd de
255	// * Xf ghi
256	// */
257	// };
258	public void testInsertNewLine10() {
259	assertNewLineBehaviour();
260	}
261
262	// class A {
263	// /*
264	// *
265	// */X
266	// };
267
268	// class A {
269	// /*
270	// *
271	// */
272	// X
273	// };
274	public void _testInsertNewLine11() { // this is correct - we're not in a dccaes partition
275	assertNewLineBehaviour();
276	}
277
278	// /X/
279
280	// /*
281	// * X
282	// */
283	public void _testInsertNewLine12() {
284	assertNewLineBehaviour();
285	}
286
287	// class A {
288	// /*Xfoo
289	// };
290
291	// class A {
292	// /*
293	// * X
294	// */foo
295	// };
296	public void testInsertNewLine13() {
297	assertNewLineBehaviour();
298	}
299
300	// class A {
301	// /*fooX
302	// };
303
304	// class A {
305	// /*foo
306	// * X
307	// */
308	// };
309	public void testInsertNewLine14() {
310	assertNewLineBehaviour();
311	}
312
313
314	// /*
315	// *
316	// *X
317
318	// /*
319	// *
320	// *
321	// *X
322	public void testInsertNewLine15() {
323	assertNewLineBehaviour();
324	}
325
326	// /*
327	// *
328	// *Xxx
329
330	// /*
331	// *
332	// *
333	// *Xxx
334	public void testInsertNewLine16() {
335	assertNewLineBehaviour();
336	}
337
338	// /*
339	// X
340
341	// /*
342	//
343	// X
344	public void testInsertNewLine17() {
345	assertNewLineBehaviour();
346	}
347
348	// /*
349	// X
350	// */
351
352	// /*
353	//
354	// X
355	// */
356	public void testInsertNewLine18() {
357	assertNewLineBehaviour();
358	}
359
360	// /*
361	// *
362	// / /X
363
364	// /*
365	// *
366	// / /
367	// * X
368	// */
369	public void _testInsertNewLine19() {
370	assertNewLineBehaviour();
371	}
372
373	// /*
374	// /*X
375	// *
376	// */
377
378	// /*
379	// /*
380	// * X
381	// *
382	// */
383	public void testInsertNewLine20() {
384	assertNewLineBehaviour();
385	}
386
387
388	//
389	// X
390	//
391	// void foo() {}
392	public void testFollowingDeclaration1() {
393	assertDeclarationFollowingX("void foo() {}");
394	}
395
396	// X
397	//
398	// void foo() {}
399	// void bar() {}
400	public void testFollowingDeclaration1b() {
401	assertDeclarationFollowingX("void foo() {}");
402	}
403
404
405	//
406	// X
407	// class C {
408	// void foo() {}
409	// };
410	public void testFollowingDeclaration2() {
411	assertDeclarationFollowingX("class C {\n void foo() {}\n };");
412	}
413
414	// class C {
415	// X
416	// void foo() {}
417	// };
418	public void testFollowingDeclaration3() {
419	assertDeclarationFollowingX("void foo() {}");
420	}
421
422	// class C {
423	// void foo() {X}
424	// void bar(int x);
425	// };
426	public void testFollowingDeclaration4() {
427	assertDeclarationFollowingX(null);
428	}
429
430	// class C {
431	// void foo() {} X
432	// void bar(int x);
433	// };
434	public void testFollowingDeclaration4a() {
435	assertDeclarationFollowingX("void bar(int x);");
436	}
437
438	// class C {
439	// void foo()X{}
440	// void bar(int x);
441	// };
442	public void _testFollowingDeclaration4b() { // XXX - this is likely invalid anyhow
443	assertDeclarationFollowingX("void foo(){}"); // (X is just the cursor position)
444	}
445
446	// class C {
447	// void foo()
448	// X
449	// {
450	// int x;
451	// }
452	// void bar(int x);
453	// };
454	public void _testFollowingDeclaration4c() { // XXX - this is likely invalid anyhow
455	assertDeclarationFollowingX("void foo()\n {\n int x;\n }\n"); // (X is just the cursor position)
456	}
457
458	// namespace n1 { X
459	// namespace n2 {
460	// void foo() {}
461	// void bar(int x) {}
462	// class C {
463	// int y;
464	// void baz(int x) {}
465	// };
466	// }
467	// }
468	public void _testFollowingDeclaration5() {
469	assertDeclarationFollowingX("namespace n2 {\n void foo() {}\n void bar(int x) {}\n class C {\n int y;\n void baz(int x) {}\n };\n }");
470	}
471
472	// namespace n1 {
473	// namespace n2 {X
474	// void foo() {}
475	// void bar(int x) {}
476	// class C {
477	// int y;
478	// void baz(int x) {}
479	// };
480	// }
481	// }
482	public void testFollowingDeclaration6() {
483	assertDeclarationFollowingX("void foo() {}");
484	}
485
486	// namespace n1 {
487	// namespace n2 {
488	// void foo() {}X
489	// void bar(int x) {}
490	// class C {
491	// int y;
492	// void baz(int x) {}
493	// };
494	// }
495	// }
496	public void testFollowingDeclaration7() {
497	assertDeclarationFollowingX("void bar(int x) {}");
498	}
499
500	// namespace n1 {
501	// namespace n2 {
502	// void foo() {}
503	// void bar(int x) {}
504	// class C {X
505	// int y;
506	// void baz(int x) {}
507	// };
508	// }
509	// }
510	public void testFollowingDeclaration8() {
511	assertDeclarationFollowingX("int y;");
512	}
513
514	// namespace n1 {
515	// namespace n2 {
516	// void foo() {}
517	// void bar(int x) {}
518	// class C {
519	// int y;X
520	// void baz(int x) {}
521	// };
522	// }
523	// }
524	public void testFollowingDeclaration9() {
525	assertDeclarationFollowingX("void baz(int x) {}");
526	}
527
528	// #define MM void foo()
529	// X
530	// MM {}
531	public void testFollowingDeclaration10() {
532	assertDeclarationFollowingX("MM {}");
533	}
534
535	// #define NAME foo
536	// #define MM(V) void V(int y)
537	// X
538	// MM(NAME) {}
539	public void testFollowingDeclaration11() {
540	assertDeclarationFollowingX("MM(NAME) {}");
541	}
542
543	// #define MAKEFUNC(V) void V()
544	// #define B(V) V
545	// #define C(V) foo ## x
546	// X
547	// MAKEFUNC(B(C(y))) {}
548	public void testFollowingDeclaration12() {
549	assertDeclarationFollowingX("MAKEFUNC(B(C(y))) {}");
550	}
551
552	/**
553	* @param rs - the raw signature of the declaration that should be returned
554	* or <code>null</code> if no declaration should be returned.
555	*/
556	protected void assertDeclarationFollowingX(String rs) {
557	try {
558	ICProject cproject= CProjectHelper.createCCProject("test"+System.currentTimeMillis(), "bin");
559	try {
560	String init= getTestContents1()[0].toString();
561	int caretInit= init.indexOf('X');
562	init= init.replaceFirst("X", "");
563	IFile file= TestSourceReader.createFile(cproject.getProject(), "this.cpp", init);
564	IASTTranslationUnit ast= TestSourceReader.createIndexBasedAST(null, cproject, file);
565	assertNotNull(ast);
566	IASTDeclaration decl= DefaultMultilineCommentAutoEditStrategy.findFollowingDeclaration(ast, caretInit);
567	if(rs!=null) {
568	assertNotNull(decl);
569	assertEquals(rs, decl.getRawSignature());
570	} else {
571	assertNull(decl);
572	}
573	} finally {
574	if(cproject!=null) {
575	cproject.getProject().delete(true, NPM);
576	}
577	}
578	} catch(CoreException ce) {
579	fail(ce.getMessage());
580	}
581	}
582
583	protected void assertNewLineBehaviour() {
584	DefaultMultilineCommentAutoEditStrategy ds= new DefaultMultilineCommentAutoEditStrategy();
585	CTextTools textTools = CUIPlugin.getDefault().getTextTools();
586	IDocument doc = new Document();
587	textTools.setupCDocument(doc);
588
589	StringBuffer[] raw= getTestContents();
590	String init= raw[0].toString(), expected= raw[1].toString();
591
592	int caretInit= init.indexOf('X');
593	init= init.replaceFirst("X", "");
594
595	int caretExpected= expected.indexOf('X');
596	expected= expected.replaceFirst("X", "");
597
598	doc.set(init);
599	int caretActual= -1;
600	try {
601	TestDocumentCommand dc= new TestDocumentCommand(caretInit, 0, "\n");
602	ds.customizeDocumentCommand(doc, dc);
603	caretActual= dc.exec(doc);
604	} catch(BadLocationException ble) {
605	fail(ble.getMessage());
606	}
607	String actual= doc.get();
608	assertEquals(expected, actual);
609	assertEquals(caretExpected, caretActual);
610	}
611
612	protected StringBuffer[] getTestContents() {
613	try {
614	return TestSourceReader.getContentsForTest(CTestPlugin.getDefault().getBundle(), "ui", this.getClass(), getName(), 2);
615	} catch(IOException ioe) {
616	fail(ioe.getMessage());
617	}
618	return null;
619	}
620
621	protected StringBuffer[] getTestContents1() {
622	try {
623	return TestSourceReader.getContentsForTest(CTestPlugin.getDefault().getBundle(), "ui", this.getClass(), getName(), 1);
624	} catch(IOException ioe) {
625	fail(ioe.getMessage());
626	}
627	return null;
628	}
629	}

Added Link Here

(-)resources/docComments/this.cpp (+24 lines)
1	// N.B: Character positions in this file are hard-coded into expected results in
2	// DocCommentHightlightTest.
3
4	/* normal0 */
5	/A comment1___ /
6	/B comment2__ /
7	/C comment3_ //D comment4___ /
8	/E comment5____ //F comment6_ /
9	/*G comment7
10	//F comment8_ //! __comment9 */
11	/**
12	comment10
13	*/
14
15	// snormal0
16	//A scomment1__
17	//B scomment2_
18	//C scomment3__
19	//! _scomment4
20	//* scomment5___
21
22	/# comment11_ #/ // scomment6__
23	/# comment12__ #/ //# __scomment7
24

Added Link Here

(-)ui/org/eclipse/cdt/ui/tests/text/AbstractAutoEditTest.java (+223 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 Wind River Systems, Inc. and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Anton Leherbauer (Wind River Systems) - initial API and implementation
10	* Sergey Prigogin, Google
11	* Andrew Ferguson (Symbian)
12	*******************************************************************************/
13	package org.eclipse.cdt.ui.tests.text;
14
15	import java.util.HashMap;
16	import java.util.Map;
17
18	import org.eclipse.jface.text.BadLocationException;
19	import org.eclipse.jface.text.DocumentCommand;
20	import org.eclipse.jface.text.IAutoEditStrategy;
21	import org.eclipse.jface.text.IDocument;
22	import org.eclipse.jface.text.IRegion;
23	import org.eclipse.jface.text.TextUtilities;
24
25	import org.eclipse.cdt.core.testplugin.util.BaseTestCase;
26
27	/**
28	* IAutoEditStrategy related tests
29	*/
30	public class AbstractAutoEditTest extends BaseTestCase {
31
32	AbstractAutoEditTest(String name) {
33	super(name);
34	}
35
36	/**
37	* Helper class to test the auto-edit strategies on a document.
38	* Split out from CAutoIndentTest.
39	*/
40	static class AutoEditTester {
41
42	private Map fStrategyMap = new HashMap();
43	IDocument fDoc;
44	private String fPartitioning;
45	private int fCaretOffset;
46
47	public AutoEditTester(IDocument doc, String partitioning) {
48	super();
49	fDoc = doc;
50	fPartitioning = partitioning;
51	}
52
53	public void setAutoEditStrategy(String contentType, IAutoEditStrategy aes) {
54	fStrategyMap.put(contentType, aes);
55	}
56
57	public IAutoEditStrategy getAutoEditStrategy(String contentType) {
58	return (IAutoEditStrategy)fStrategyMap.get(contentType);
59	}
60
61	/**
62	* Empties the document, and returns the caret to the origin (0,0)
63	* @return <code>this</code> for method chaining
64	*/
65	public AutoEditTester reset() {
66	try {
67	goTo(0,0);
68	fDoc.set("");
69	} catch(BadLocationException ble) {
70	fail(ble.getMessage());
71	}
72	return this;
73	}
74
75	public void type(String text) throws BadLocationException {
76	for (int i = 0; i < text.length(); ++i) {
77	type(text.charAt(i));
78	}
79	}
80
81	public void type(char c) throws BadLocationException {
82	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, new String(new char[] { c }));
83	customizeDocumentCommand(command);
84	fCaretOffset = command.exec(fDoc);
85	}
86
87	private void customizeDocumentCommand(TestDocumentCommand command) throws BadLocationException {
88	IAutoEditStrategy aes = getAutoEditStrategy(getContentType(command.offset));
89	if (aes != null) {
90	aes.customizeDocumentCommand(fDoc, command);
91	}
92	}
93
94	public void type(int offset, String text) throws BadLocationException {
95	fCaretOffset = offset;
96	type(text);
97	}
98
99	public void type(int offset, char c) throws BadLocationException {
100	fCaretOffset = offset;
101	type(c);
102	}
103
104	public void paste(String text) throws BadLocationException {
105	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset, 0, text);
106	customizeDocumentCommand(command);
107	fCaretOffset = command.exec(fDoc);
108	}
109
110	public void paste(int offset, String text) throws BadLocationException {
111	fCaretOffset = offset;
112	paste(text);
113	}
114
115	public void backspace(int n) throws BadLocationException {
116	for (int i = 0; i < n; ++i) {
117	backspace();
118	}
119	}
120
121	public void backspace() throws BadLocationException {
122	TestDocumentCommand command = new TestDocumentCommand(fCaretOffset - 1, 1, ""); //$NON-NLS-1$
123	customizeDocumentCommand(command);
124	fCaretOffset = command.exec(fDoc);
125	}
126
127	public int getCaretOffset() {
128	return fCaretOffset;
129	}
130
131	public int setCaretOffset(int offset) {
132	fCaretOffset = offset;
133	if (fCaretOffset < 0)
134	fCaretOffset = 0;
135	else if (fCaretOffset > fDoc.getLength())
136	fCaretOffset = fDoc.getLength();
137	return fCaretOffset;
138	}
139
140	/**
141	* Moves caret right or left by the given number of characters.
142	*
143	* @param shift Move distance.
144	* @return New caret offset.
145	*/
146	public int moveCaret(int shift) {
147	return setCaretOffset(fCaretOffset + shift);
148	}
149
150	public int goTo(int line) throws BadLocationException {
151	fCaretOffset = fDoc.getLineOffset(line);
152	return fCaretOffset;
153	}
154
155	public int goTo(int line, int column) throws BadLocationException {
156	if (column < 0 \|\| column > fDoc.getLineLength(line)) {
157	throw new BadLocationException("No column " + column + " in line " + line); //$NON-NLS-1$ $NON-NLS-2$
158	}
159	fCaretOffset = fDoc.getLineOffset(line) + column;
160	return fCaretOffset;
161	}
162
163	public int getCaretLine() throws BadLocationException {
164	return fDoc.getLineOfOffset(fCaretOffset);
165	}
166
167	public int getCaretColumn() throws BadLocationException {
168	IRegion region = fDoc.getLineInformationOfOffset(fCaretOffset);
169	return fCaretOffset - region.getOffset();
170	}
171
172	public char getChar() throws BadLocationException {
173	return getChar(0);
174	}
175
176	public char getChar(int i) throws BadLocationException {
177	return fDoc.getChar(fCaretOffset+i);
178	}
179
180	public String getLine() throws BadLocationException {
181	return getLine(0);
182	}
183
184	public String getLine(int i) throws BadLocationException {
185	IRegion region = fDoc.getLineInformation(getCaretLine() + i);
186	return fDoc.get(region.getOffset(), region.getLength());
187	}
188
189	public String getContentType(int offset) throws BadLocationException {
190	return TextUtilities.getContentType(fDoc, fPartitioning, offset, true);
191	}
192	}
193
194	/**
195	* A DocumentCommand with public constructor and exec method.
196	*/
197	static class TestDocumentCommand extends DocumentCommand {
198
199	public TestDocumentCommand(int offset, int length, String text) {
200	super();
201	doit = true;
202	this.text = text;
203
204	this.offset = offset;
205	this.length = length;
206
207	owner = null;
208	caretOffset = -1;
209	}
210
211	/**
212	* @param doc
213	* @return the new caret position.
214	* @throws BadLocationException
215	*/
216	public int exec(IDocument doc) throws BadLocationException {
217	doc.replace(offset, length, text);
218	return caretOffset != -1 ?
219	caretOffset :
220	offset + (text == null ? 0 : text.length());
221	}
222	}
223	}