Eclipse PDE: Everything about Editor Part 5

Code Completion using Content Assist

This post explains about completion proposal feature of eclipse editor framework. This is part of Everything About Editor series. Content assist provides content assist help to developer while writing code in editor. It helps from static suggestion of language keyword to methods suggestion for dynamic reference on hitting “Ctrl-Space” or entering  any of activator character like ‘.’.

Following two interfaces plays key role in implementing code completion for customer editor.

  • ICompletionProposal – Responsible for providing set of proposals text, associated icons etc.
  • IContentAssistProcessor – Responsible for calculating the completion proposals at a point in the editor. It also defines character on which it shoud auto-activate.

In this example we are going to see providing content assist then user enters ‘#’. To achieve this we need to implement IComppletionProposal that will return set of proposals as well as tells framework which character activate content assist by overriding getCompletionProposalAutoActivationCharacters() method from same interface.

public class MyContentAssistProcessor implements IContentAssistProcessor {
 
    @Override
    public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer,
            int offset) {
        String text = getTobeCompleteText(viewer.getDocument(), offset);
        return new ICompletionProposal[]{
            new MyCompletionProposal("Proposal 1",offset,text.length()),
            new MyCompletionProposal("Proposal 2",offset,text.length())
        };
    }
 
    @Override
    public IContextInformation[] computeContextInformation(ITextViewer viewer,
            int offset) {
        // TODO Auto-generated method stub
        return null;
    }
 
    @Override
    public char[] getCompletionProposalAutoActivationCharacters() {
        return new char[] {'#'};
    }
 
    @Override
    public char[] getContextInformationAutoActivationCharacters() {
        // TODO Auto-generated method stub
        return null;
    }
 
    @Override
    public String getErrorMessage() {
        // TODO Auto-generated method stub
        return null;
    }
 
    @Override
    public IContextInformationValidator getContextInformationValidator() {
        // TODO Auto-generated method stub
        return null;
    }
    
    private boolean isWhiteSpace(char c){
        if(c=='\n'||c=='\t'||c==' ')
            return true;
        return false;
    }
    
    private String getTobeCompleteText(IDocument document, int currentOffset){
 
        int count = currentOffset;
        String tobeCompleteText="";
        try{
            while(--count>=0){
                char c = ' ';
                c = document.getChar(count);
 
                if(isWhiteSpace(c)){
                    break;
                }
            }
            tobeCompleteText = document.get(count+1, currentOffset-(count+1));
 
        }catch (Exception e) {
            e.printStackTrace();
        }
        return tobeCompleteText;
    }
}

Second task is to implement ICompletionProposal interface that actually handles proposals. It provides text and image to be displayed in proposal window, inserting proposal text to editor.



public class MyCompletionProposal implements ICompletionProposal {
 
    String text;
    int offset,contextTextLength;
    MyCompletionProposal(String text,int offset,int contextTextLength){
        this.text = text;
        this.offset = offset;
        this.contextTextLength = contextTextLength;
    }
    @Override
    public void apply(IDocument document) {
        try {
            document.replace(offset, 0, text);
            
        } catch (BadLocationException e) {
            e.printStackTrace();
        }
    }
 
    @Override
    public Point getSelection(IDocument document) {
        // TODO Auto-generated method stub
        return null;
    }
 
    @Override
    public String getAdditionalProposalInfo() {
        // TODO Auto-generated method stub
        return null;
    }
 
    @Override
    public String getDisplayString() {
        return text;
    }
 
    @Override
    public Image getImage() {
        return null;
    }
 
    @Override
    public IContextInformation getContextInformation() {
        return null;
    }
 
}

And Final task to update SourceViewConfiguration to install the custom content assist proposal


image

Comments

  1. UnknownJune 11, 2014 at 7:53 AM

    This comment has been removed by the author.

    ReplyDelete
  2. UnknownJune 11, 2014 at 7:55 AM

    Nice work man! Your PDE series is clear and precise.

    Can you tell me how to add the default content assist for (say) javascript provided by eclipse to my editor.I don't want to write the entire content assist as is given by eclipse again for my editor.

    Thanks in advance.

    ReplyDelete

Post a Comment

Popular posts from this blog

Composite Design Pattern by example

Image
This post explains Composite design pattern with an example. When to use ? – Use Composite pattern when you have treat a collection of objects as they were once one thing. With Composite design pattern it is very easy to simplify operations over collection data structure. It reduces complexity of the code required if you were going to handle collection as special case. How to Use? - The Composite pattern consist of Component, Leaf and Composite Classes as shown below class diagram Component – Component declares the common interface that both the single and composite nodes will implements Leaf – The leaf class represent the singular atomic data type implementing he component interface.     Composite – Composite is an abstract entity which declares common functionality which are needed by concrete implementation for handling collection data. An Example -   Item.java public interface Item {     public double getPrice(); }   ColdDrink.java pu
Read more

State Design Pattern by Example

Image
State pattern falls under the category of Behavioral patterns. State design pattern comes in picture when a system’s behavior is depends on its own state or some other resource’s state. If an implementation is depends on the states, we end up with snarl of conditional statement every where in code. A very neat approach to deal with such situation is to separate out every state’s behavior and use them where ever they are applicable. The state pattern allows an object to alter its behavior when is internal state changes . The object is appeared to change its class. State pattern is a way to implement the same. Class Diagram : As above class diagram shows, System class holds state instance. As state of system changes , all handle request delegated to respective State’s concrete implementation. Example : Have an example of Vending machine. Vending machine has following states No Coin Inserted Coin Inserted Dispensing Empty Following diagram explain behavior
Read more

Eclipse command framework core expression: Property tester

Image
Addition to Eclipse command framework series, this post explains use of property tester to control command’s enable/visible properties. In earlier post we have tried declarative way to achieve same thing but property tester gives us more control. Property tester is associated with, tester class which implements PropertyTester.java, a namespace and set of property which it supports. We can refer this property tester using its namespace + a property name. It gives you call back to test() method with property name as parameter inside property tester class. We can configure property tester for type of input parameter. Here is sample declaration of property tester extension point < extension point ="org.eclipse.core.expressions.propertyTesters" > < propertyTester class ="com.example.advance.cmd.EditorTester" id ="com.example.advance.cmd.propertyTester1" namespace ="com.example.advance.cm
Read more