Difference between revisions of "DLTK IDE Guide:Step 3. Towards an IDE"

public class ExamplePythonSearchPage extends ScriptSearchPage {
	protected IDLTKLanguageToolkit getLanguageToolkit() {
		return ExamplePythonLanguageToolkit.getDefault();
	}
}

public class ExamplePythonSearchFactory extends AbstractSearchFactory {
	public IMatchLocatorParser createMatchParser(MatchLocator locator) {
		return new ExamplePythonMatchLocationParser(locator);
	}
}

public class ExamplePythonMatchLocationParser extends MatchLocatorParser {
	protected ExamplePythonMatchLocationParser(MatchLocator locator) {
		super(locator);
	}
	protected void processStatement(ASTNode node, PatternLocator locator) {
		super.processStatement(node, locator);
		if (node instanceof ExtendedVariableReference) {
			ExtendedVariableReference ref = (ExtendedVariableReference) node;
			int expressionCount = ref.getExpressionCount();
			for (int i = 0; i < expressionCount; i++) {
				Expression e = ref.getExpression(i);
				if (ref.isCall(i) && e instanceof VariableReference) {
					CallExpression call = new CallExpression(null,
							((VariableReference) e).getName(), null);
					call.setStart(e.sourceStart());
					call.setEnd(e.sourceEnd());
					locator.match(call, getNodeSet());
				} else if (e instanceof VariableReference) {
					locator.match(node, getNodeSet());
				}
			}
		}
		if (node instanceof VariableReference) {
			locator.match(node, getNodeSet());
		}
	}
}

public class ExamplePythonOpenTypeAction extends OpenTypeAction {
	protected IDLTKUILanguageToolkit getUILanguageToolkit() {
		return new ExamplePythonUILanguageToolkit();
	}
}

public class ExamplePythonSelectionEngine implements ISelectionEngine {
	private org.eclipse.dltk.core.ISourceModule sourceModule;
 
	public IModelElement[] select(ISourceModule module, final int offset, int i) {
		sourceModule = (org.eclipse.dltk.core.ISourceModule) module
				.getModelElement();
		ModuleDeclaration moduleDeclaration = SourceParserUtil
				.getModuleDeclaration(sourceModule, null);
		final List results = new ArrayList();
		try {
			moduleDeclaration.traverse(new ASTVisitor() {
				public boolean visit(Expression s) throws Exception {
					if (s.sourceStart() <= offset && offset <= s.sourceEnd()) {
						if (s instanceof ExtendedVariableReference) {
							ExtendedVariableReference ref = (ExtendedVariableReference) s;
							int count = ref.getExpressionCount();
							for (int j = 0; j < count; j++) {
								Expression e = ref.getExpression(j);
								if (e.sourceStart() <= offset
										&& offset <= e.sourceEnd()) {
									if (e instanceof VariableReference) {
										findDeclaration(((VariableReference) e)
												.getName(), results);
									}
								}
							}
						} else if (s instanceof VariableReference) {
							findDeclaration(((VariableReference) s).getName(),
									results);
						}
					}
					return super.visit(s);
				}
 
				public boolean visit(MethodDeclaration s) throws Exception {
					if (s.getNameStart() <= offset && offset <= s.getNameEnd()) {
						findDeclaration(s.getName(), results);
					}
					return super.visit(s);
				}
 
				public boolean visit(TypeDeclaration s) throws Exception {
					if (s.getNameStart() <= offset && offset <= s.getNameEnd()) {
						findDeclaration(s.getName(), results);
					}
					return super.visit(s);
				}
 
			});
		} catch (Exception e) {
			if (DLTKCore.DEBUG) {
				e.printStackTrace();
			}
		}
		return (IModelElement[]) results.toArray(new IModelElement[results
				.size()]);
	}
 
	private void findDeclaration(final String name, final List results) {
		try {
			this.sourceModule.accept(new IModelElementVisitor() {
				public boolean visit(IModelElement element) {
					if (element.getElementName().equals(name)) {
						results.add(element);
					}
					return true;
				}
			});
		} catch (ModelException e) {
			if (DLTKCore.DEBUG) {
				e.printStackTrace();
			}
		}
	}
 
	public void setOptions(Map options) {
	}
}

public class ExamplePythonCommentDocumentationProvider implements
		IScriptDocumentationProvider {
 
	protected String getLine(Document d, int line) throws BadLocationException {
		return d.get(d.getLineOffset(line), d.getLineLength(line));
	}
 
	protected String getHeaderComment(IMember member) {
		try {
			ISourceRange range = member.getSourceRange();
			if (range == null)
				return null;
 
			IBuffer buf = null;
 
			ISourceModule compilationUnit = member.getSourceModule();
			if (!compilationUnit.isConsistent()) {
				return null;
			}
 
			buf = compilationUnit.getBuffer();
 
			final int start = range.getOffset();
 
			String contents = buf.getContents();
 
			String result = "";
 
			Document doc = new Document(contents);
			try {
				int line = doc.getLineOfOffset(start);
				line--;
				if (line < 0)
					return null;
				boolean emptyEnd = true;
				while (line >= 0) {
					String curLine = getLine(doc, line);
					String curLineTrimmed = curLine.trim();
					if ((curLineTrimmed.length() == 0 && emptyEnd)
							|| curLineTrimmed.startsWith("#")) {
						if (curLineTrimmed.length() != 0)
							emptyEnd = false;
						result = curLine + result;
					} else
						break;
 
					line--;
				}
			} catch (BadLocationException e) {
				return null;
			}
 
			return result;
 
		} catch (ModelException e) {
		}
		return null;
	}
 
	public Reader getInfo(IMember member, boolean lookIntoParents,
			boolean lookIntoExternal) {
		String header = getHeaderComment(member);
		return new StringReader(convertToHTML(header));
	}
 
	protected String convertToHTML(String header) {
		StringBuffer result = new StringBuffer();
		// result.append("<p>\n");
		Document d = new Document(header);
		for (int line = 0;; line++) {
			try {
				String str = getLine(d, line).trim();
				if (str == null)
					break;
				while (str.length() > 0 && str.startsWith("#"))
					str = str.substring(1);
				while (str.length() > 0 && str.endsWith("#"))
					str = str.substring(0, str.length() - 1);
				if (str.length() == 0)
					result.append("<p>");
				else {
					if (str.trim().matches("\\w*:")) {
						result.append("<h4>");
						result.append(str);
						result.append("</h4>");
					} else
						result.append(str + "<br>");
				}
			} catch (BadLocationException e) {
				break;
			}
 
		}
		return result.toString();
	}
 
	public Reader getInfo(String content) {
		return null;
	}
}

public class ExamplePythonCompletionEngine implements ICompletionEngine {
	IScriptProject project;
	private CompletionRequestor requestor;
	private int actualCompletionPosition;
	private int offset;
 
	public void complete(ISourceModule module, int position, int pos) {
		this.actualCompletionPosition = position;
		this.offset = pos;
		String[] keywords = new String[] { "and", "del", "for", "is", "raise",
				"assert", "elif", "from", "lambda", "break", "else", "global",
				"not", "try", "class", "except", "if", "or", "while",
				"continue", "exec", "import", "pass", "yield", "def",
				"finally", "in", "print", "self", "return" };
		for (int j = 0; j < keywords.length; j++) {
			createProposal(keywords[[j]], null);
		}
 
		// Completion for model elements.
		try {
			module.getModelElement().accept(new IModelElementVisitor() {
				public boolean visit(IModelElement element) {
					if (element.getElementType() > IModelElement.SOURCE_MODULE) {
						createProposal(element.getElementName(), element);
					}
					return true;
				}
			});
		} catch (ModelException e) {
			if (DLTKCore.DEBUG) {
				e.printStackTrace();
			}
		}
	}
 
	private void createProposal(String name, IModelElement element) {
		CompletionProposal proposal = null;
		try {
			if (element == null) {
				proposal = this.createProposal(CompletionProposal.KEYWORD,
						this.actualCompletionPosition);
			} else {
				switch (element.getElementType()) {
				case IModelElement.METHOD:
					proposal = this.createProposal(
							CompletionProposal.METHOD_DECLARATION,
							this.actualCompletionPosition);
					proposal.setFlags(((IMethod) element).getFlags());
					break;
				case IModelElement.FIELD:
					proposal = this.createProposal(
							CompletionProposal.FIELD_REF,
							this.actualCompletionPosition);
					proposal.setFlags(((IField) element).getFlags());
					break;
				case IModelElement.TYPE:
					proposal = this.createProposal(CompletionProposal.TYPE_REF,
							this.actualCompletionPosition);
					proposal.setFlags(((IType) element).getFlags());
					break;
				default:
					proposal = this.createProposal(CompletionProposal.KEYWORD,
							this.actualCompletionPosition);
					break;
				}
			}
			proposal.setName(name.toCharArray());
			proposal.setCompletion(name.toCharArray());
			proposal.setReplaceRange(actualCompletionPosition - offset,
					actualCompletionPosition - offset);
			proposal.setRelevance(20);
			proposal.setModelElement(element);
			this.requestor.accept(proposal);
		} catch (Exception e) {
		}
	}
	public void setOptions(Map options) {
	}
	public void setProject(IScriptProject project) {
		this.project = project;
	}
	public void setRequestor(CompletionRequestor requestor) {
		this.requestor = requestor;
	}
	protected CompletionProposal createProposal(int kind, int completionOffset) {
		return CompletionProposal.create(kind,
				completionOffset - this.offset);
	}
}

public class ExamplePythonCompletionProposalComputer extends
		ScriptCompletionProposalComputer {
 
	public ExamplePythonCompletionProposalComputer() {
	}
 
	protected ScriptCompletionProposalCollector createCollector(
			ScriptContentAssistInvocationContext context) {
		return new ExamplePythonCompletionProposalCollector(context.getSourceModule());
	}
 
	protected TemplateCompletionProcessor createTemplateProposalComputer(
			ScriptContentAssistInvocationContext context) {
		return null;
	}
}

public class ExamplePythonCompletionProposalCollector extends
		ScriptCompletionProposalCollector {
 
	protected final static char[] VAR_TRIGGER = { '\t', ' ', '=', ';', '.' };
 
	protected char[] getVarTrigger() {
		return VAR_TRIGGER;
	}
 
	public ExamplePythonCompletionProposalCollector(ISourceModule module) {
		super(module);
	}
 
	// Specific proposals creation. May be use factory?
	protected ScriptCompletionProposal createScriptCompletionProposal(
			String completion, int replaceStart, int length, Image image,
			String displayString, int i) {
		return new ExamplePythonCompletionProposal(completion, replaceStart, length,
				image, displayString, i);
	}
 
	protected ScriptCompletionProposal createScriptCompletionProposal(
			String completion, int replaceStart, int length, Image image,
			String displayString, int i, boolean isInDoc) {
		return new ExamplePythonCompletionProposal(completion, replaceStart, length,
				image, displayString, i, isInDoc);
	}
 
	protected ScriptCompletionProposal createOverrideCompletionProposal(
			IScriptProject scriptProject, ISourceModule compilationUnit,
			String name, String[] paramTypes, int start, int length,
			String displayName, String completionProposal) {
		return new ExamplePythonOverrideCompletionProposal(scriptProject, compilationUnit,
				name, paramTypes, start, length, displayName,
				completionProposal);
	}
}

public class ExamplePythonCompletionProposal extends ScriptCompletionProposal {
	public ExamplePythonCompletionProposal(String replacementString,
			int replacementOffset, int replacementLength, Image image,
			String displayString, int relevance) {
		super(replacementString, replacementOffset, replacementLength, image,
				displayString, relevance);
	}
	public ExamplePythonCompletionProposal(String replacementString,
			int replacementOffset, int replacementLength, Image image,
			String displayString, int relevance, boolean isInDoc) {
		super(replacementString, replacementOffset, replacementLength, image,
				displayString, relevance, isInDoc);
	}
	protected boolean isSmartTrigger(char trigger) {
		if (trigger == '.') {
			return true;
		}
		return false;
	}
	protected boolean insertCompletion() {
		IPreferenceStore preference = PythonCorePlugin.getDefault()
				.getPreferenceStore();
		return preference
				.getBoolean(PreferenceConstants.CODEASSIST_INSERT_COMPLETION);
	}
}

public class ExamplePythonCompletionProcessor extends ScriptCompletionProcessor {
	public ExamplePythonCompletionProcessor(IEditorPart editor,
			ContentAssistant assistant, String partition) {
		super(editor, assistant, partition);
	}
 
	protected String getNatureId() {
		return ExamplePythonNature.PYTHON_NATURE;
	}
 
	protected CompletionProposalLabelProvider getProposalLabelProvider() {
		return new CompletionProposalLabelProvider();
	}
	protected IPreferenceStore getPreferenceStore() {
		return PythonCorePlugin.getDefault().getPreferenceStore();
	}
}

protected void alterContentAssistant(ContentAssistant assistant) {
		// IDocument.DEFAULT_CONTENT_TYPE
		IContentAssistProcessor scriptProcessor = new ExamplePythonCompletionProcessor(
				getEditor(), assistant, IDocument.DEFAULT_CONTENT_TYPE);
		assistant.setContentAssistProcessor(scriptProcessor,
				IDocument.DEFAULT_CONTENT_TYPE);
	}

public class ExamplePythonUniversalTemplateContextType extends
		ScriptTemplateContextType {
 
	public static final String CONTEXT_TYPE_ID = "examplePythonUniversalTemplateContextType";
 
	public ExamplePythonUniversalTemplateContextType() {
	}
 
	public ExamplePythonUniversalTemplateContextType(String id, String name) {
		super(id, name);
	}
 
	public ExamplePythonUniversalTemplateContextType(String id) {
		super(id);
	}
 
	public ScriptTemplateContext createContext(IDocument document,
			int completionPosition, int length, ISourceModule sourceModule) {
		return new ExamplePythonTemplateContext(this, document, completionPosition,
				length, sourceModule);
	}
}

public class ExamplePythonTemplateContext extends ScriptTemplateContext {
	protected ExamplePythonTemplateContext(TemplateContextType type,
			IDocument document, int completionOffset, int completionLength,
			ISourceModule sourceModule) {
		super(type, document, completionOffset, completionLength, sourceModule);
	}
}

public class ExamplePythonTemplateCompletionProcessor extends
		ScriptTemplateCompletionProcessor {
 
	private static char[] IGNORE = {'.'};
 
	public ExamplePythonTemplateCompletionProcessor(
			ScriptContentAssistInvocationContext context) {
		super(context);
	}
 
	protected String getContextTypeId() {
		return ExamplePythonUniversalTemplateContextType.CONTEXT_TYPE_ID;
	}
 
	protected char[] getIgnore() {
		return IGNORE;
	}
	protected ScriptTemplateAccess getTemplateAccess() {
		return ExamplePythonTemplateAccess.getInstance();
	}
}

public class ExamplePythonTemplateAccess extends ScriptTemplateAccess {
 
	private static final String CUSTOM_TEMPLATES_KEY = "org.eclipse.dtlk.example.python.Templates";
 
	private static ExamplePythonTemplateAccess instance;
 
	public static ExamplePythonTemplateAccess getInstance() {
		if (instance == null) {
			instance = new ExamplePythonTemplateAccess();
		}
 
		return instance;
	}
 
	protected String getContextTypeId() {
		return ExamplePythonUniversalTemplateContextType.CONTEXT_TYPE_ID;
	}
	protected String getCustomTemplatesKey() {
		return CUSTOM_TEMPLATES_KEY;
	}
 
	protected IPreferenceStore getPreferenceStore() {
		return ExamplePythonUI.getDefault().getPreferenceStore();
	}
}

public class ExamplePythonCodeTemplatesPreferencePage extends
		ScriptTemplatePreferencePage {
	protected ScriptSourceViewerConfiguration createSourceViewerConfiguration() {
		return new ExampleSimplePythonSourceViewerConfiguration(getTextTools()
				.getColorManager(), getPreferenceStore(), null,
				IExamplePythonPartitions.PYTHON_PARTITIONING, false);
	}
	protected void setDocumentParticioner(IDocument document) {
		getTextTools().setupDocumentPartitioner(document,
				IExamplePythonPartitions.PYTHON_PARTITIONING);
	}
	protected void setPreferenceStore() {
		setPreferenceStore(ExamplePythonUI.getDefault().getPreferenceStore());
	}
	protected ScriptTemplateAccess getTemplateAccess() {
		return ExamplePythonTemplateAccess.getInstance();
	}
	private ExamplePythonTextTools getTextTools() {
		return ExamplePythonUI.getDefault().getTextTools();
	}
}

public class ExamplePythonUILanguageToolkit2 extends
		ExamplePythonUILanguageToolkit {
	public ScriptSourceViewerConfiguration createSourceViewerConfiguration() {
		return new ExampleSimplePythonSourceViewerConfiguration(getTextTools()
				.getColorManager(), getPreferenceStore(), null,
				getPartitioningId(), false);
	}
}

public class ExampleSimplePythonSourceViewerConfiguration extends
		ExamplePythonSourceViewerConfiguration {
	private boolean fConfigureFormatter;
 
	public ExampleSimplePythonSourceViewerConfiguration(
			IColorManager colorManager, IPreferenceStore preferenceStore,
			ITextEditor editor, String partitioning, boolean configureFormatter) {
		super(colorManager, preferenceStore, editor, partitioning);
		fConfigureFormatter = configureFormatter;
	}
 
	public IAutoEditStrategy[] getAutoEditStrategies(
			ISourceViewer sourceViewer, String contentType) {
		return null;
	}
 
	public IAnnotationHover getAnnotationHover(ISourceViewer sourceViewer) {
		return null;
	}
 
	public IAnnotationHover getOverviewRulerAnnotationHover(
			ISourceViewer sourceViewer) {
		return null;
	}
 
	public int[] getConfiguredTextHoverStateMasks(ISourceViewer sourceViewer,
			String contentType) {
		return null;
	}
 
	public ITextHover getTextHover(ISourceViewer sourceViewer,
			String contentType, int stateMask) {
		return null;
	}
 
	public ITextHover getTextHover(ISourceViewer sourceViewer,
			String contentType) {
		return null;
	}
 
	public IContentFormatter getContentFormatter(ISourceViewer sourceViewer) {
		if (fConfigureFormatter)
			return super.getContentFormatter(sourceViewer);
		else
			return null;
	}
 
	public IInformationControlCreator getInformationControlCreator(
			ISourceViewer sourceViewer) {
		return null;
	}
 
	public IInformationPresenter getInformationPresenter(
			ISourceViewer sourceViewer) {
		return null;
	}
 
	public IInformationPresenter getOutlinePresenter(
			ISourceViewer sourceViewer, boolean doCodeResolve) {
		return null;
	}
 
	public IInformationPresenter getHierarchyPresenter(
			ISourceViewer sourceViewer, boolean doCodeResolve) {
		return null;
	}
 
	public IHyperlinkDetector[] getHyperlinkDetectors(ISourceViewer sourceViewer) {
		return null;
	}
}